(function webpackUniversalModuleDefinition(root, factory) {
    if(typeof exports === 'object' && typeof module === 'object')
        module.exports = factory();
    else if(typeof define === 'function' && define.amd)
        define([], factory);
    else if(typeof exports === 'object')
        exports["qiniu"] = factory();
    else
        root["qiniu"] = factory();
})(typeof self !== 'undefined' ? self : this, function() {
    return /******/ (function(modules) { // webpackBootstrap
        /******/ 	// The module cache
        /******/ 	var installedModules = {};
        /******/
        /******/ 	// The require function
        /******/ 	function __webpack_require__(moduleId) {
            /******/
            /******/ 		// Check if module is in cache
            /******/ 		if(installedModules[moduleId]) {
                /******/ 			return installedModules[moduleId].exports;
                /******/ 		}
            /******/ 		// Create a new module (and put it into the cache)
            /******/ 		var module = installedModules[moduleId] = {
                /******/ 			i: moduleId,
                /******/ 			l: false,
                /******/ 			exports: {}
                /******/ 		};
            /******/
            /******/ 		// Execute the module function
            /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/
            /******/ 		// Flag the module as loaded
            /******/ 		module.l = true;
            /******/
            /******/ 		// Return the exports of the module
            /******/ 		return module.exports;
            /******/ 	}
        /******/
        /******/
        /******/ 	// expose the modules object (__webpack_modules__)
        /******/ 	__webpack_require__.m = modules;
        /******/
        /******/ 	// expose the module cache
        /******/ 	__webpack_require__.c = installedModules;
        /******/
        /******/ 	// define getter function for harmony exports
        /******/ 	__webpack_require__.d = function(exports, name, getter) {
            /******/ 		if(!__webpack_require__.o(exports, name)) {
                /******/ 			Object.defineProperty(exports, name, {
                    /******/ 				configurable: false,
                    /******/ 				enumerable: true,
                    /******/ 				get: getter
                    /******/ 			});
                /******/ 		}
            /******/ 	};
        /******/
        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
        /******/ 	__webpack_require__.n = function(module) {
            /******/ 		var getter = module && module.__esModule ?
                /******/ 			function getDefault() { return module['default']; } :
                /******/ 			function getModuleExports() { return module; };
            /******/ 		__webpack_require__.d(getter, 'a', getter);
            /******/ 		return getter;
            /******/ 	};
        /******/
        /******/ 	// Object.prototype.hasOwnProperty.call
        /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
        /******/
        /******/ 	// __webpack_public_path__
        /******/ 	__webpack_require__.p = "/dist/";
        /******/
        /******/ 	// Load entry module and return exports
        /******/ 	return __webpack_require__(__webpack_require__.s = 58);
        /******/ })
    /************************************************************************/
    /******/ ([
        /* 0 */
        /***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
            var global = module.exports = typeof window != 'undefined' && window.Math == Math
                ? window : typeof self != 'undefined' && self.Math == Math ? self
                    // eslint-disable-next-line no-new-func
                    : Function('return this')();
            if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef


            /***/ }),
        /* 1 */
        /***/ (function(module, exports, __webpack_require__) {

            var store = __webpack_require__(28)('wks');
            var uid = __webpack_require__(19);
            var Symbol = __webpack_require__(0).Symbol;
            var USE_SYMBOL = typeof Symbol == 'function';

            var $exports = module.exports = function (name) {
                return store[name] || (store[name] =
                        USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
            };

            $exports.store = store;


            /***/ }),
        /* 2 */
        /***/ (function(module, exports) {

            var core = module.exports = { version: '2.5.3' };
            if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef


            /***/ }),
        /* 3 */
        /***/ (function(module, exports, __webpack_require__) {

            var isObject = __webpack_require__(7);
            module.exports = function (it) {
                if (!isObject(it)) throw TypeError(it + ' is not an object!');
                return it;
            };


            /***/ }),
        /* 4 */
        /***/ (function(module, exports, __webpack_require__) {

            var global = __webpack_require__(0);
            var core = __webpack_require__(2);
            var ctx = __webpack_require__(16);
            var hide = __webpack_require__(5);
            var PROTOTYPE = 'prototype';

            var $export = function (type, name, source) {
                var IS_FORCED = type & $export.F;
                var IS_GLOBAL = type & $export.G;
                var IS_STATIC = type & $export.S;
                var IS_PROTO = type & $export.P;
                var IS_BIND = type & $export.B;
                var IS_WRAP = type & $export.W;
                var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
                var expProto = exports[PROTOTYPE];
                var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
                var key, own, out;
                if (IS_GLOBAL) source = name;
                for (key in source) {
                    // contains in native
                    own = !IS_FORCED && target && target[key] !== undefined;
                    if (own && key in exports) continue;
                    // export native or passed
                    out = own ? target[key] : source[key];
                    // prevent global pollution for namespaces
                    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
                        // bind timers to global for call from export context
                        : IS_BIND && own ? ctx(out, global)
                            // wrap global constructors for prevent change them in library
                            : IS_WRAP && target[key] == out ? (function (C) {
                                var F = function (a, b, c) {
                                    if (this instanceof C) {
                                        switch (arguments.length) {
                                            case 0: return new C();
                                            case 1: return new C(a);
                                            case 2: return new C(a, b);
                                        } return new C(a, b, c);
                                    } return C.apply(this, arguments);
                                };
                                F[PROTOTYPE] = C[PROTOTYPE];
                                return F;
                                // make static versions for prototype methods
                            })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
                    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
                    if (IS_PROTO) {
                        (exports.virtual || (exports.virtual = {}))[key] = out;
                        // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
                        if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
                    }
                }
            };
// type bitmap
            $export.F = 1;   // forced
            $export.G = 2;   // global
            $export.S = 4;   // static
            $export.P = 8;   // proto
            $export.B = 16;  // bind
            $export.W = 32;  // wrap
            $export.U = 64;  // safe
            $export.R = 128; // real proto method for `library`
            module.exports = $export;


            /***/ }),
        /* 5 */
        /***/ (function(module, exports, __webpack_require__) {

            var dP = __webpack_require__(6);
            var createDesc = __webpack_require__(18);
            module.exports = __webpack_require__(8) ? function (object, key, value) {
                return dP.f(object, key, createDesc(1, value));
            } : function (object, key, value) {
                object[key] = value;
                return object;
            };


            /***/ }),
        /* 6 */
        /***/ (function(module, exports, __webpack_require__) {

            var anObject = __webpack_require__(3);
            var IE8_DOM_DEFINE = __webpack_require__(38);
            var toPrimitive = __webpack_require__(24);
            var dP = Object.defineProperty;

            exports.f = __webpack_require__(8) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
                anObject(O);
                P = toPrimitive(P, true);
                anObject(Attributes);
                if (IE8_DOM_DEFINE) try {
                    return dP(O, P, Attributes);
                } catch (e) { /* empty */ }
                if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
                if ('value' in Attributes) O[P] = Attributes.value;
                return O;
            };


            /***/ }),
        /* 7 */
        /***/ (function(module, exports) {

            module.exports = function (it) {
                return typeof it === 'object' ? it !== null : typeof it === 'function';
            };


            /***/ }),
        /* 8 */
        /***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
            module.exports = !__webpack_require__(10)(function () {
                return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
            });


            /***/ }),
        /* 9 */
        /***/ (function(module, exports) {

            var hasOwnProperty = {}.hasOwnProperty;
            module.exports = function (it, key) {
                return hasOwnProperty.call(it, key);
            };


            /***/ }),
        /* 10 */
        /***/ (function(module, exports) {

            module.exports = function (exec) {
                try {
                    return !!exec();
                } catch (e) {
                    return true;
                }
            };


            /***/ }),
        /* 11 */
        /***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings
            var IObject = __webpack_require__(40);
            var defined = __webpack_require__(25);
            module.exports = function (it) {
                return IObject(defined(it));
            };


            /***/ }),
        /* 12 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 / 15.2.3.14 Object.keys(O)
            var $keys = __webpack_require__(39);
            var enumBugKeys = __webpack_require__(29);

            module.exports = Object.keys || function keys(O) {
                    return $keys(O, enumBugKeys);
                };


            /***/ }),
        /* 13 */
        /***/ (function(module, exports) {

            var toString = {}.toString;

            module.exports = function (it) {
                return toString.call(it).slice(8, -1);
            };


            /***/ }),
        /* 14 */
        /***/ (function(module, exports) {

            module.exports = {};


            /***/ }),
        /* 15 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;

            var _assign = __webpack_require__(37);

            var _assign2 = _interopRequireDefault(_assign);

            var _stringify = __webpack_require__(64);

            var _stringify2 = _interopRequireDefault(_stringify);

            var _promise = __webpack_require__(42);

            var _promise2 = _interopRequireDefault(_promise);

            var _keys = __webpack_require__(55);

            var _keys2 = _interopRequireDefault(_keys);

            exports.isChunkExpired = isChunkExpired;
            exports.getChunks = getChunks;
            exports.filterParams = filterParams;
            exports.getLocalFileInfoAndMd5 = getLocalFileInfoAndMd5;
            exports.sum = sum;
            exports.setLocalFileInfo = setLocalFileInfo;
            exports.removeLocalFileInfo = removeLocalFileInfo;
            exports.createMkFileUrl = createMkFileUrl;
            exports.getHeadersForChunkUpload = getHeadersForChunkUpload;
            exports.getHeadersForMkFile = getHeadersForMkFile;
            exports.createXHR = createXHR;
            exports.readAsArrayBuffer = readAsArrayBuffer;
            exports.request = request;
            exports.getPortFromUrl = getPortFromUrl;
            exports.getDomainFromUrl = getDomainFromUrl;
            exports.getUploadUrl = getUploadUrl;
            exports.isContainFileMimeType = isContainFileMimeType;

            var _base = __webpack_require__(56);

            var _config = __webpack_require__(36);

            var _sparkMd = __webpack_require__(90);

            var _sparkMd2 = _interopRequireDefault(_sparkMd);

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

// 对上传块本地存储时间检验是否过期
// TODO: 最好用服务器时间来做判断
            function isChunkExpired(time) {
                var expireAt = time + 3600 * 24 * 1000;
                return new Date().getTime() > expireAt;
            }

// 文件分块
            function getChunks(file, blockSize) {
                var chunks = [];
                var count = Math.ceil(file.size / blockSize);
                for (var i = 0; i < count; i++) {
                    var chunk = file.slice(blockSize * i, i === count - 1 ? file.size : blockSize * (i + 1));
                    chunks.push(chunk);
                }
                return chunks;
            }

            function filterParams(params) {
                return (0, _keys2["default"])(params).filter(function (value) {
                    return value.startsWith("x:");
                }).map(function (k) {
                    return [k, params[k].toString()];
                });
            }

// check本地存储的信息
            function getLocalFileInfoAndMd5(file) {
                return new _promise2["default"](function (resolve, reject) {
                    readAsArrayBuffer(file).then(function (body) {
                        var spark = new _sparkMd2["default"].ArrayBuffer();
                        spark.append(body);
                        var md5 = spark.end();
                        var localFileInfo = getLocalFileInfo(file.name, md5);
                        resolve({ md5: md5, info: localFileInfo });
                    })["catch"](function (err) {
                        resolve({ md5: "", info: [] });
                    });
                });
            }

            function sum(list) {
                return list.reduce(function (sum, loaded) {
                    return sum + loaded;
                }, 0);
            }

            function setLocalFileInfo(name, md5, info) {
                try {
                    localStorage.setItem(createLocalKey(name, md5), (0, _stringify2["default"])(info));
                } catch (err) {
                    if (window.console && window.console.warn) {
                        console.warn("setLocalFileInfo failed");
                    }
                }
            }

            function createLocalKey(name, md5) {
                return "qiniu_js_sdk_upload_file_md5_" + md5 + "_" + name;
            }

            function removeLocalFileInfo(name, md5) {
                try {
                    localStorage.removeItem(createLocalKey(name, md5));
                } catch (err) {
                    if (window.console && window.console.warn) {
                        console.warn("removeLocalFileInfo failed");
                    }
                }
            }

            function getLocalFileInfo(name, md5) {
                try {
                    return JSON.parse(localStorage.getItem(createLocalKey(name, md5))) || [];
                } catch (err) {
                    if (window.console && window.console.warn) {
                        console.warn("getLocalFileInfo failed");
                    }
                    return [];
                }
            }

// 构造file上传url
            function createMkFileUrl(url, size, key, putExtra) {
                var requestUrl = url + "/mkfile/" + size;
                if (key != null) {
                    requestUrl += "/key/" + (0, _base.urlSafeBase64Encode)(key);
                }
                if (putExtra.mimeType) {
                    requestUrl += "/mimeType/" + (0, _base.urlSafeBase64Encode)(putExtra.mimeType);
                }
                var fname = putExtra.fname;
                if (fname) {
                    requestUrl += "/fname/" + (0, _base.urlSafeBase64Encode)(fname);
                }
                if (putExtra.params) {
                    filterParams(putExtra.params).forEach(function (item) {
                        return requestUrl += "/" + encodeURIComponent(item[0]) + "/" + (0, _base.urlSafeBase64Encode)(item[1]);
                    });
                }
                return requestUrl;
            }

            function getAuthHeaders(token) {
                var auth = "UpToken " + token;
                return { Authorization: auth };
            }

            function getHeadersForChunkUpload(token) {
                var header = getAuthHeaders(token);
                return (0, _assign2["default"])({ "content-type": "application/octet-stream" }, header);
            }

            function getHeadersForMkFile(token) {
                var header = getAuthHeaders(token);
                return (0, _assign2["default"])({ "content-type": "text/plain" }, header);
            }

            function createXHR() {
                if (window.XMLHttpRequest) {
                    return new XMLHttpRequest();
                }
                return new ActiveXObject("Microsoft.XMLHTTP");
            };

            function readAsArrayBuffer(data) {
                return new _promise2["default"](function (resolve, reject) {
                    var reader = new FileReader();
                    reader.readAsArrayBuffer(data);
                    reader.onload = function (evt) {
                        var body = evt.target.result;
                        resolve(body);
                    };
                    reader.onerror = function () {
                        reject(new Error("fileReader 读取错误"));
                    };
                });
            }

            function request(url, options) {
                return new _promise2["default"](function (resolve, reject) {
                    var xhr = createXHR();
                    xhr.open(options.method, url);

                    if (options.onCreate) {
                        options.onCreate(xhr);
                    }
                    if (options.headers) {
                        (0, _keys2["default"])(options.headers).forEach(function (k) {
                            return xhr.setRequestHeader(k, options.headers[k]);
                        });
                    }

                    xhr.upload.addEventListener("progress", function (evt) {
                        if (evt.lengthComputable && options.onProgress) {
                            options.onProgress({ loaded: evt.loaded, total: evt.total });
                        }
                    });

                    xhr.onreadystatechange = function () {
                        var responseText = xhr.responseText;
                        if (xhr.readyState !== 4) {
                            return;
                        }
                        var reqId = xhr.getResponseHeader("x-reqId") || "";
                        if (xhr.status !== 200) {
                            var message = "xhr request failed, code: " + xhr.status + ";";
                            if (responseText) {
                                message = message + (" response: " + responseText);
                            }
                            reject({ code: xhr.status, message: message, reqId: reqId, isRequestError: true });
                            return;
                        }
                        try {
                            resolve({ data: JSON.parse(responseText), reqId: reqId });
                        } catch (err) {
                            reject(err);
                        }
                    };

                    xhr.send(options.body);
                });
            }

            function getPortFromUrl(url) {
                if (url && url.match) {
                    var groups = url.match(/(^https?)/);
                    if (!groups) {
                        return "";
                    }
                    var type = groups[1];
                    groups = url.match(/^https?:\/\/([^:^/]*):(\d*)/);
                    if (groups) {
                        return groups[2];
                    }
                    if (type === "http") {
                        return "80";
                    }
                    return "443";
                }
                return "";
            }

            function getDomainFromUrl(url) {
                if (url && url.match) {
                    var groups = url.match(/^https?:\/\/([^:^/]*)/);
                    return groups ? groups[1] : "";
                }
                return "";
            }

// 构造区域上传url
            function getUploadUrl(config) {
                var upHosts = _config.regionUphostMap[config.region] || _config.regionUphostMap[_config.region.z0];
                var protocol = window.location.protocol === 'https:' ? "https" : "http";
                var host = config.useCdnDomain ? upHosts.cdnUphost : upHosts.srcUphost;
                return protocol + "://" + host;
            }

            function isContainFileMimeType(fileType, mimeType) {
                return mimeType.indexOf(fileType) > -1;
            }

            /***/ }),
        /* 16 */
        /***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
            var aFunction = __webpack_require__(17);
            module.exports = function (fn, that, length) {
                aFunction(fn);
                if (that === undefined) return fn;
                switch (length) {
                    case 1: return function (a) {
                        return fn.call(that, a);
                    };
                    case 2: return function (a, b) {
                        return fn.call(that, a, b);
                    };
                    case 3: return function (a, b, c) {
                        return fn.call(that, a, b, c);
                    };
                }
                return function (/* ...args */) {
                    return fn.apply(that, arguments);
                };
            };


            /***/ }),
        /* 17 */
        /***/ (function(module, exports) {

            module.exports = function (it) {
                if (typeof it != 'function') throw TypeError(it + ' is not a function!');
                return it;
            };


            /***/ }),
        /* 18 */
        /***/ (function(module, exports) {

            module.exports = function (bitmap, value) {
                return {
                    enumerable: !(bitmap & 1),
                    configurable: !(bitmap & 2),
                    writable: !(bitmap & 4),
                    value: value
                };
            };


            /***/ }),
        /* 19 */
        /***/ (function(module, exports) {

            var id = 0;
            var px = Math.random();
            module.exports = function (key) {
                return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
            };


            /***/ }),
        /* 20 */
        /***/ (function(module, exports) {

            exports.f = {}.propertyIsEnumerable;


            /***/ }),
        /* 21 */
        /***/ (function(module, exports) {

            module.exports = true;


            /***/ }),
        /* 22 */
        /***/ (function(module, exports, __webpack_require__) {

            var def = __webpack_require__(6).f;
            var has = __webpack_require__(9);
            var TAG = __webpack_require__(1)('toStringTag');

            module.exports = function (it, tag, stat) {
                if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
            };


            /***/ }),
        /* 23 */
        /***/ (function(module, exports, __webpack_require__) {

            var isObject = __webpack_require__(7);
            var document = __webpack_require__(0).document;
// typeof document.createElement is 'object' in old IE
            var is = isObject(document) && isObject(document.createElement);
            module.exports = function (it) {
                return is ? document.createElement(it) : {};
            };


            /***/ }),
        /* 24 */
        /***/ (function(module, exports, __webpack_require__) {

// 7.1.1 ToPrimitive(input [, PreferredType])
            var isObject = __webpack_require__(7);
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
            module.exports = function (it, S) {
                if (!isObject(it)) return it;
                var fn, val;
                if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
                if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
                if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
                throw TypeError("Can't convert object to primitive value");
            };


            /***/ }),
        /* 25 */
        /***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)
            module.exports = function (it) {
                if (it == undefined) throw TypeError("Can't call method on  " + it);
                return it;
            };


            /***/ }),
        /* 26 */
        /***/ (function(module, exports) {

// 7.1.4 ToInteger
            var ceil = Math.ceil;
            var floor = Math.floor;
            module.exports = function (it) {
                return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
            };


            /***/ }),
        /* 27 */
        /***/ (function(module, exports, __webpack_require__) {

            var shared = __webpack_require__(28)('keys');
            var uid = __webpack_require__(19);
            module.exports = function (key) {
                return shared[key] || (shared[key] = uid(key));
            };


            /***/ }),
        /* 28 */
        /***/ (function(module, exports, __webpack_require__) {

            var global = __webpack_require__(0);
            var SHARED = '__core-js_shared__';
            var store = global[SHARED] || (global[SHARED] = {});
            module.exports = function (key) {
                return store[key] || (store[key] = {});
            };


            /***/ }),
        /* 29 */
        /***/ (function(module, exports) {

// IE 8- don't enum bug keys
            module.exports = (
                'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
            ).split(',');


            /***/ }),
        /* 30 */
        /***/ (function(module, exports) {

            exports.f = Object.getOwnPropertySymbols;


            /***/ }),
        /* 31 */
        /***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
            var defined = __webpack_require__(25);
            module.exports = function (it) {
                return Object(defined(it));
            };


            /***/ }),
        /* 32 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

// 25.4.1.5 NewPromiseCapability(C)
            var aFunction = __webpack_require__(17);

            function PromiseCapability(C) {
                var resolve, reject;
                this.promise = new C(function ($$resolve, $$reject) {
                    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
                    resolve = $$resolve;
                    reject = $$reject;
                });
                this.resolve = aFunction(resolve);
                this.reject = aFunction(reject);
            }

            module.exports.f = function (C) {
                return new PromiseCapability(C);
            };


            /***/ }),
        /* 33 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;

            exports["default"] = function (instance, Constructor) {
                if (!(instance instanceof Constructor)) {
                    throw new TypeError("Cannot call a class as a function");
                }
            };

            /***/ }),
        /* 34 */
        /***/ (function(module, exports, __webpack_require__) {

            exports.f = __webpack_require__(1);


            /***/ }),
        /* 35 */
        /***/ (function(module, exports, __webpack_require__) {

            var global = __webpack_require__(0);
            var core = __webpack_require__(2);
            var LIBRARY = __webpack_require__(21);
            var wksExt = __webpack_require__(34);
            var defineProperty = __webpack_require__(6).f;
            module.exports = function (name) {
                var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
                if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });
            };


            /***/ }),
        /* 36 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            var regionUphostMap = exports.regionUphostMap = {
                z0: {
                    srcUphost: "up.qiniup.com",
                    cdnUphost: "upload.qiniup.com"
                },
                z1: {
                    srcUphost: "up-z1.qiniup.com",
                    cdnUphost: "upload-z1.qiniup.com"
                },
                z2: {
                    srcUphost: "up-z2.qiniup.com",
                    cdnUphost: "upload-z2.qiniup.com"
                },
                na0: {
                    srcUphost: "up-na0.qiniup.com",
                    cdnUphost: "upload-na0.qiniup.com"
                },
                as0: {
                    srcUphost: "up-as0.qiniup.com",
                    cdnUphost: "upload-as0.qiniup.com"
                }
            };

            var region = exports.region = {
                z0: "z0",
                z1: "z1",
                z2: "z2",
                na0: "na0",
                as0: "as0"
            };

            /***/ }),
        /* 37 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(59), __esModule: true };

            /***/ }),
        /* 38 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = !__webpack_require__(8) && !__webpack_require__(10)(function () {
                    return Object.defineProperty(__webpack_require__(23)('div'), 'a', { get: function () { return 7; } }).a != 7;
                });


            /***/ }),
        /* 39 */
        /***/ (function(module, exports, __webpack_require__) {

            var has = __webpack_require__(9);
            var toIObject = __webpack_require__(11);
            var arrayIndexOf = __webpack_require__(62)(false);
            var IE_PROTO = __webpack_require__(27)('IE_PROTO');

            module.exports = function (object, names) {
                var O = toIObject(object);
                var i = 0;
                var result = [];
                var key;
                for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
                // Don't enum bug & hidden keys
                while (names.length > i) if (has(O, key = names[i++])) {
                    ~arrayIndexOf(result, key) || result.push(key);
                }
                return result;
            };


            /***/ }),
        /* 40 */
        /***/ (function(module, exports, __webpack_require__) {

// fallback for non-array-like ES3 and non-enumerable old V8 strings
            var cof = __webpack_require__(13);
// eslint-disable-next-line no-prototype-builtins
            module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
                return cof(it) == 'String' ? it.split('') : Object(it);
            };


            /***/ }),
        /* 41 */
        /***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength
            var toInteger = __webpack_require__(26);
            var min = Math.min;
            module.exports = function (it) {
                return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
            };


            /***/ }),
        /* 42 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(66), __esModule: true };

            /***/ }),
        /* 43 */
        /***/ (function(module, exports) {



            /***/ }),
        /* 44 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var $at = __webpack_require__(67)(true);

// 21.1.3.27 String.prototype[@@iterator]()
            __webpack_require__(45)(String, 'String', function (iterated) {
                this._t = String(iterated); // target
                this._i = 0;                // next index
// 21.1.5.2.1 %StringIteratorPrototype%.next()
            }, function () {
                var O = this._t;
                var index = this._i;
                var point;
                if (index >= O.length) return { value: undefined, done: true };
                point = $at(O, index);
                this._i += point.length;
                return { value: point, done: false };
            });


            /***/ }),
        /* 45 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var LIBRARY = __webpack_require__(21);
            var $export = __webpack_require__(4);
            var redefine = __webpack_require__(46);
            var hide = __webpack_require__(5);
            var has = __webpack_require__(9);
            var Iterators = __webpack_require__(14);
            var $iterCreate = __webpack_require__(68);
            var setToStringTag = __webpack_require__(22);
            var getPrototypeOf = __webpack_require__(70);
            var ITERATOR = __webpack_require__(1)('iterator');
            var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
            var FF_ITERATOR = '@@iterator';
            var KEYS = 'keys';
            var VALUES = 'values';

            var returnThis = function () { return this; };

            module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
                $iterCreate(Constructor, NAME, next);
                var getMethod = function (kind) {
                    if (!BUGGY && kind in proto) return proto[kind];
                    switch (kind) {
                        case KEYS: return function keys() { return new Constructor(this, kind); };
                        case VALUES: return function values() { return new Constructor(this, kind); };
                    } return function entries() { return new Constructor(this, kind); };
                };
                var TAG = NAME + ' Iterator';
                var DEF_VALUES = DEFAULT == VALUES;
                var VALUES_BUG = false;
                var proto = Base.prototype;
                var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
                var $default = (!BUGGY && $native) || getMethod(DEFAULT);
                var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
                var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
                var methods, key, IteratorPrototype;
                // Fix native
                if ($anyNative) {
                    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
                    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
                        // Set @@toStringTag to native iterators
                        setToStringTag(IteratorPrototype, TAG, true);
                        // fix for some old engines
                        if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
                    }
                }
                // fix Array#{values, @@iterator}.name in V8 / FF
                if (DEF_VALUES && $native && $native.name !== VALUES) {
                    VALUES_BUG = true;
                    $default = function values() { return $native.call(this); };
                }
                // Define iterator
                if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
                    hide(proto, ITERATOR, $default);
                }
                // Plug for library
                Iterators[NAME] = $default;
                Iterators[TAG] = returnThis;
                if (DEFAULT) {
                    methods = {
                        values: DEF_VALUES ? $default : getMethod(VALUES),
                        keys: IS_SET ? $default : getMethod(KEYS),
                        entries: $entries
                    };
                    if (FORCED) for (key in methods) {
                        if (!(key in proto)) redefine(proto, key, methods[key]);
                    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
                }
                return methods;
            };


            /***/ }),
        /* 46 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = __webpack_require__(5);


            /***/ }),
        /* 47 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
            var anObject = __webpack_require__(3);
            var dPs = __webpack_require__(69);
            var enumBugKeys = __webpack_require__(29);
            var IE_PROTO = __webpack_require__(27)('IE_PROTO');
            var Empty = function () { /* empty */ };
            var PROTOTYPE = 'prototype';

// Create object with fake `null` prototype: use iframe Object with cleared prototype
            var createDict = function () {
                // Thrash, waste and sodomy: IE GC bug
                var iframe = __webpack_require__(23)('iframe');
                var i = enumBugKeys.length;
                var lt = '<';
                var gt = '>';
                var iframeDocument;
                iframe.style.display = 'none';
                __webpack_require__(48).appendChild(iframe);
                iframe.src = 'javascript:'; // eslint-disable-line no-script-url
                // createDict = iframe.contentWindow.Object;
                // html.removeChild(iframe);
                iframeDocument = iframe.contentWindow.document;
                iframeDocument.open();
                iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
                iframeDocument.close();
                createDict = iframeDocument.F;
                while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
                return createDict();
            };

            module.exports = Object.create || function create(O, Properties) {
                    var result;
                    if (O !== null) {
                        Empty[PROTOTYPE] = anObject(O);
                        result = new Empty();
                        Empty[PROTOTYPE] = null;
                        // add "__proto__" for Object.getPrototypeOf polyfill
                        result[IE_PROTO] = O;
                    } else result = createDict();
                    return Properties === undefined ? result : dPs(result, Properties);
                };


            /***/ }),
        /* 48 */
        /***/ (function(module, exports, __webpack_require__) {

            var document = __webpack_require__(0).document;
            module.exports = document && document.documentElement;


            /***/ }),
        /* 49 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(71);
            var global = __webpack_require__(0);
            var hide = __webpack_require__(5);
            var Iterators = __webpack_require__(14);
            var TO_STRING_TAG = __webpack_require__(1)('toStringTag');

            var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
            'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
            'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
            'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
            'TextTrackList,TouchList').split(',');

            for (var i = 0; i < DOMIterables.length; i++) {
                var NAME = DOMIterables[i];
                var Collection = global[NAME];
                var proto = Collection && Collection.prototype;
                if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
                Iterators[NAME] = Iterators.Array;
            }


            /***/ }),
        /* 50 */
        /***/ (function(module, exports, __webpack_require__) {

// getting tag from 19.1.3.6 Object.prototype.toString()
            var cof = __webpack_require__(13);
            var TAG = __webpack_require__(1)('toStringTag');
// ES3 wrong here
            var ARG = cof(function () { return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
            var tryGet = function (it, key) {
                try {
                    return it[key];
                } catch (e) { /* empty */ }
            };

            module.exports = function (it) {
                var O, T, B;
                return it === undefined ? 'Undefined' : it === null ? 'Null'
                    // @@toStringTag case
                    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
                        // builtinTag case
                        : ARG ? cof(O)
                            // ES3 arguments fallback
                            : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
            };


            /***/ }),
        /* 51 */
        /***/ (function(module, exports, __webpack_require__) {

// 7.3.20 SpeciesConstructor(O, defaultConstructor)
            var anObject = __webpack_require__(3);
            var aFunction = __webpack_require__(17);
            var SPECIES = __webpack_require__(1)('species');
            module.exports = function (O, D) {
                var C = anObject(O).constructor;
                var S;
                return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
            };


            /***/ }),
        /* 52 */
        /***/ (function(module, exports, __webpack_require__) {

            var ctx = __webpack_require__(16);
            var invoke = __webpack_require__(80);
            var html = __webpack_require__(48);
            var cel = __webpack_require__(23);
            var global = __webpack_require__(0);
            var process = global.process;
            var setTask = global.setImmediate;
            var clearTask = global.clearImmediate;
            var MessageChannel = global.MessageChannel;
            var Dispatch = global.Dispatch;
            var counter = 0;
            var queue = {};
            var ONREADYSTATECHANGE = 'onreadystatechange';
            var defer, channel, port;
            var run = function () {
                var id = +this;
                // eslint-disable-next-line no-prototype-builtins
                if (queue.hasOwnProperty(id)) {
                    var fn = queue[id];
                    delete queue[id];
                    fn();
                }
            };
            var listener = function (event) {
                run.call(event.data);
            };
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
            if (!setTask || !clearTask) {
                setTask = function setImmediate(fn) {
                    var args = [];
                    var i = 1;
                    while (arguments.length > i) args.push(arguments[i++]);
                    queue[++counter] = function () {
                        // eslint-disable-next-line no-new-func
                        invoke(typeof fn == 'function' ? fn : Function(fn), args);
                    };
                    defer(counter);
                    return counter;
                };
                clearTask = function clearImmediate(id) {
                    delete queue[id];
                };
                // Node.js 0.8-
                if (__webpack_require__(13)(process) == 'process') {
                    defer = function (id) {
                        process.nextTick(ctx(run, id, 1));
                    };
                    // Sphere (JS game engine) Dispatch API
                } else if (Dispatch && Dispatch.now) {
                    defer = function (id) {
                        Dispatch.now(ctx(run, id, 1));
                    };
                    // Browsers with MessageChannel, includes WebWorkers
                } else if (MessageChannel) {
                    channel = new MessageChannel();
                    port = channel.port2;
                    channel.port1.onmessage = listener;
                    defer = ctx(port.postMessage, port, 1);
                    // Browsers with postMessage, skip WebWorkers
                    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
                } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
                    defer = function (id) {
                        global.postMessage(id + '', '*');
                    };
                    global.addEventListener('message', listener, false);
                    // IE8-
                } else if (ONREADYSTATECHANGE in cel('script')) {
                    defer = function (id) {
                        html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
                            html.removeChild(this);
                            run.call(id);
                        };
                    };
                    // Rest old browsers
                } else {
                    defer = function (id) {
                        setTimeout(ctx(run, id, 1), 0);
                    };
                }
            }
            module.exports = {
                set: setTask,
                clear: clearTask
            };


            /***/ }),
        /* 53 */
        /***/ (function(module, exports) {

            module.exports = function (exec) {
                try {
                    return { e: false, v: exec() };
                } catch (e) {
                    return { e: true, v: e };
                }
            };


            /***/ }),
        /* 54 */
        /***/ (function(module, exports, __webpack_require__) {

            var anObject = __webpack_require__(3);
            var isObject = __webpack_require__(7);
            var newPromiseCapability = __webpack_require__(32);

            module.exports = function (C, x) {
                anObject(C);
                if (isObject(x) && x.constructor === C) return x;
                var promiseCapability = newPromiseCapability.f(C);
                var resolve = promiseCapability.resolve;
                resolve(x);
                return promiseCapability.promise;
            };


            /***/ }),
        /* 55 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(87), __esModule: true };

            /***/ }),
        /* 56 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.urlSafeBase64Encode = urlSafeBase64Encode;
            function utf8Encode(argString) {
                // http://kevin.vanzonneveld.net
                // +   original by: Webtoolkit.info (http://www.webtoolkit.info/)
                // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
                // +   improved by: sowberry
                // +    tweaked by: Jack
                // +   bugfixed by: Onno Marsman
                // +   improved by: Yves Sucaet
                // +   bugfixed by: Onno Marsman
                // +   bugfixed by: Ulrich
                // +   bugfixed by: Rafal Kukawski
                // +   improved by: kirilloid
                // +   bugfixed by: kirilloid
                // *     example 1: this.utf8Encode('Kevin van Zonneveld');
                // *     returns 1: 'Kevin van Zonneveld'

                if (argString === null || typeof argString === "undefined") {
                    return "";
                }

                var string = argString + ""; // .replace(/\r\n/g, '\n').replace(/\r/g, '\n');
                var utftext = "",
                    start = void 0,
                    end = void 0,
                    stringl = 0;

                start = end = 0;
                stringl = string.length;
                for (var n = 0; n < stringl; n++) {
                    var c1 = string.charCodeAt(n);
                    var enc = null;

                    if (c1 < 128) {
                        end++;
                    } else if (c1 > 127 && c1 < 2048) {
                        enc = String.fromCharCode(c1 >> 6 | 192, c1 & 63 | 128);
                    } else if (c1 & 0xf800 ^ 0xd800 > 0) {
                        enc = String.fromCharCode(c1 >> 12 | 224, c1 >> 6 & 63 | 128, c1 & 63 | 128);
                    } else {
                        // surrogate pairs
                        if (c1 & 0xfc00 ^ 0xd800 > 0) {
                            throw new RangeError("Unmatched trail surrogate at " + n);
                        }
                        var c2 = string.charCodeAt(++n);
                        if (c2 & 0xfc00 ^ 0xdc00 > 0) {
                            throw new RangeError("Unmatched lead surrogate at " + (n - 1));
                        }
                        c1 = ((c1 & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
                        enc = String.fromCharCode(c1 >> 18 | 240, c1 >> 12 & 63 | 128, c1 >> 6 & 63 | 128, c1 & 63 | 128);
                    }
                    if (enc !== null) {
                        if (end > start) {
                            utftext += string.slice(start, end);
                        }
                        utftext += enc;
                        start = end = n + 1;
                    }
                }

                if (end > start) {
                    utftext += string.slice(start, stringl);
                }

                return utftext;
            }

            function base64Encode(data) {
                // http://kevin.vanzonneveld.net
                // +   original by: Tyler Akins (http://rumkin.com)
                // +   improved by: Bayron Guevara
                // +   improved by: Thunder.m
                // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
                // +   bugfixed by: Pellentesque Malesuada
                // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
                // -    depends on: this.utf8Encode
                // *     example 1: this.base64Encode('Kevin van Zonneveld');
                // *     returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
                // mozilla has this native
                // - but breaks in 2.0.0.12!
                //if (typeof this.window['atob'] == 'function') {
                //    return atob(data);
                //}
                var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
                var o1 = void 0,
                    o2 = void 0,
                    o3 = void 0,
                    h1 = void 0,
                    h2 = void 0,
                    h3 = void 0,
                    h4 = void 0,
                    bits = void 0,
                    i = 0,
                    ac = 0,
                    enc = "",
                    tmp_arr = [];

                if (!data) {
                    return data;
                }

                data = utf8Encode(data + "");

                do {
                    // pack three octets into four hexets
                    o1 = data.charCodeAt(i++);
                    o2 = data.charCodeAt(i++);
                    o3 = data.charCodeAt(i++);

                    bits = o1 << 16 | o2 << 8 | o3;

                    h1 = bits >> 18 & 0x3f;
                    h2 = bits >> 12 & 0x3f;
                    h3 = bits >> 6 & 0x3f;
                    h4 = bits & 0x3f;

                    // use hexets to index into b64, and append result to encoded string
                    tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
                } while (i < data.length);

                enc = tmp_arr.join("");

                switch (data.length % 3) {
                    case 1:
                        enc = enc.slice(0, -2) + "==";
                        break;
                    case 2:
                        enc = enc.slice(0, -1) + "=";
                        break;
                }

                return enc;
            }

            function urlSafeBase64Encode(v) {
                v = base64Encode(v);
                return v.replace(/\//g, "_").replace(/\+/g, "-");
            }

            /***/ }),
        /* 57 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
            var $keys = __webpack_require__(39);
            var hiddenKeys = __webpack_require__(29).concat('length', 'prototype');

            exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
                    return $keys(O, hiddenKeys);
                };


            /***/ }),
        /* 58 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.pipeline = exports.exif = exports.imageInfo = exports.watermark = exports.imageMogr2 = exports.getUploadUrl = exports.filterParams = exports.getHeadersForMkFile = exports.getHeadersForChunkUpload = exports.createMkFileUrl = exports.region = exports.upload = undefined;

            var _config = __webpack_require__(36);

            var _utils = __webpack_require__(15);

            var _upload = __webpack_require__(91);

            var _image = __webpack_require__(92);

            var _observable = __webpack_require__(93);

            var _statisticsLog = __webpack_require__(107);

            var statisticsLogger = new _statisticsLog.StatisticsLogger();

            function upload(file, key, token, putExtra, config) {

                var options = {
                    file: file,
                    key: key,
                    token: token,
                    putExtra: putExtra,
                    config: config
                };

                return new _observable.Observable(function (observer) {
                    var uploadManager = new _upload.UploadManager(options, {
                        onData: function onData(e) {
                            return observer.next(e);
                        },
                        onError: function onError(e) {
                            return observer.error(e);
                        },
                        onComplete: function onComplete(e) {
                            return observer.complete(e);
                        }
                    }, statisticsLogger);
                    uploadManager.putFile();
                    return uploadManager.stop.bind(uploadManager);
                });
            }

            exports.upload = upload;
            exports.region = _config.region;
            exports.createMkFileUrl = _utils.createMkFileUrl;
            exports.getHeadersForChunkUpload = _utils.getHeadersForChunkUpload;
            exports.getHeadersForMkFile = _utils.getHeadersForMkFile;
            exports.filterParams = _utils.filterParams;
            exports.getUploadUrl = _utils.getUploadUrl;
            exports.imageMogr2 = _image.imageMogr2;
            exports.watermark = _image.watermark;
            exports.imageInfo = _image.imageInfo;
            exports.exif = _image.exif;
            exports.pipeline = _image.pipeline;

            /***/ }),
        /* 59 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(60);
            module.exports = __webpack_require__(2).Object.assign;


            /***/ }),
        /* 60 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.3.1 Object.assign(target, source)
            var $export = __webpack_require__(4);

            $export($export.S + $export.F, 'Object', { assign: __webpack_require__(61) });


            /***/ }),
        /* 61 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

// 19.1.2.1 Object.assign(target, source, ...)
            var getKeys = __webpack_require__(12);
            var gOPS = __webpack_require__(30);
            var pIE = __webpack_require__(20);
            var toObject = __webpack_require__(31);
            var IObject = __webpack_require__(40);
            var $assign = Object.assign;

// should work with symbols and should have deterministic property order (V8 bug)
            module.exports = !$assign || __webpack_require__(10)(function () {
                var A = {};
                var B = {};
                // eslint-disable-next-line no-undef
                var S = Symbol();
                var K = 'abcdefghijklmnopqrst';
                A[S] = 7;
                K.split('').forEach(function (k) { B[k] = k; });
                return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
            }) ? function assign(target, source) { // eslint-disable-line no-unused-vars
                var T = toObject(target);
                var aLen = arguments.length;
                var index = 1;
                var getSymbols = gOPS.f;
                var isEnum = pIE.f;
                while (aLen > index) {
                    var S = IObject(arguments[index++]);
                    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
                    var length = keys.length;
                    var j = 0;
                    var key;
                    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
                } return T;
            } : $assign;


            /***/ }),
        /* 62 */
        /***/ (function(module, exports, __webpack_require__) {

// false -> Array#indexOf
// true  -> Array#includes
            var toIObject = __webpack_require__(11);
            var toLength = __webpack_require__(41);
            var toAbsoluteIndex = __webpack_require__(63);
            module.exports = function (IS_INCLUDES) {
                return function ($this, el, fromIndex) {
                    var O = toIObject($this);
                    var length = toLength(O.length);
                    var index = toAbsoluteIndex(fromIndex, length);
                    var value;
                    // Array#includes uses SameValueZero equality algorithm
                    // eslint-disable-next-line no-self-compare
                    if (IS_INCLUDES && el != el) while (length > index) {
                        value = O[index++];
                        // eslint-disable-next-line no-self-compare
                        if (value != value) return true;
                        // Array#indexOf ignores holes, Array#includes - not
                    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
                        if (O[index] === el) return IS_INCLUDES || index || 0;
                    } return !IS_INCLUDES && -1;
                };
            };


            /***/ }),
        /* 63 */
        /***/ (function(module, exports, __webpack_require__) {

            var toInteger = __webpack_require__(26);
            var max = Math.max;
            var min = Math.min;
            module.exports = function (index, length) {
                index = toInteger(index);
                return index < 0 ? max(index + length, 0) : min(index, length);
            };


            /***/ }),
        /* 64 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(65), __esModule: true };

            /***/ }),
        /* 65 */
        /***/ (function(module, exports, __webpack_require__) {

            var core = __webpack_require__(2);
            var $JSON = core.JSON || (core.JSON = { stringify: JSON.stringify });
            module.exports = function stringify(it) { // eslint-disable-line no-unused-vars
                return $JSON.stringify.apply($JSON, arguments);
            };


            /***/ }),
        /* 66 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(43);
            __webpack_require__(44);
            __webpack_require__(49);
            __webpack_require__(74);
            __webpack_require__(85);
            __webpack_require__(86);
            module.exports = __webpack_require__(2).Promise;


            /***/ }),
        /* 67 */
        /***/ (function(module, exports, __webpack_require__) {

            var toInteger = __webpack_require__(26);
            var defined = __webpack_require__(25);
// true  -> String#at
// false -> String#codePointAt
            module.exports = function (TO_STRING) {
                return function (that, pos) {
                    var s = String(defined(that));
                    var i = toInteger(pos);
                    var l = s.length;
                    var a, b;
                    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
                    a = s.charCodeAt(i);
                    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
                        ? TO_STRING ? s.charAt(i) : a
                        : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
                };
            };


            /***/ }),
        /* 68 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var create = __webpack_require__(47);
            var descriptor = __webpack_require__(18);
            var setToStringTag = __webpack_require__(22);
            var IteratorPrototype = {};

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
            __webpack_require__(5)(IteratorPrototype, __webpack_require__(1)('iterator'), function () { return this; });

            module.exports = function (Constructor, NAME, next) {
                Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
                setToStringTag(Constructor, NAME + ' Iterator');
            };


            /***/ }),
        /* 69 */
        /***/ (function(module, exports, __webpack_require__) {

            var dP = __webpack_require__(6);
            var anObject = __webpack_require__(3);
            var getKeys = __webpack_require__(12);

            module.exports = __webpack_require__(8) ? Object.defineProperties : function defineProperties(O, Properties) {
                anObject(O);
                var keys = getKeys(Properties);
                var length = keys.length;
                var i = 0;
                var P;
                while (length > i) dP.f(O, P = keys[i++], Properties[P]);
                return O;
            };


            /***/ }),
        /* 70 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
            var has = __webpack_require__(9);
            var toObject = __webpack_require__(31);
            var IE_PROTO = __webpack_require__(27)('IE_PROTO');
            var ObjectProto = Object.prototype;

            module.exports = Object.getPrototypeOf || function (O) {
                    O = toObject(O);
                    if (has(O, IE_PROTO)) return O[IE_PROTO];
                    if (typeof O.constructor == 'function' && O instanceof O.constructor) {
                        return O.constructor.prototype;
                    } return O instanceof Object ? ObjectProto : null;
                };


            /***/ }),
        /* 71 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var addToUnscopables = __webpack_require__(72);
            var step = __webpack_require__(73);
            var Iterators = __webpack_require__(14);
            var toIObject = __webpack_require__(11);

// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
            module.exports = __webpack_require__(45)(Array, 'Array', function (iterated, kind) {
                this._t = toIObject(iterated); // target
                this._i = 0;                   // next index
                this._k = kind;                // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
            }, function () {
                var O = this._t;
                var kind = this._k;
                var index = this._i++;
                if (!O || index >= O.length) {
                    this._t = undefined;
                    return step(1);
                }
                if (kind == 'keys') return step(0, index);
                if (kind == 'values') return step(0, O[index]);
                return step(0, [index, O[index]]);
            }, 'values');

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
            Iterators.Arguments = Iterators.Array;

            addToUnscopables('keys');
            addToUnscopables('values');
            addToUnscopables('entries');


            /***/ }),
        /* 72 */
        /***/ (function(module, exports) {

            module.exports = function () { /* empty */ };


            /***/ }),
        /* 73 */
        /***/ (function(module, exports) {

            module.exports = function (done, value) {
                return { value: value, done: !!done };
            };


            /***/ }),
        /* 74 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var LIBRARY = __webpack_require__(21);
            var global = __webpack_require__(0);
            var ctx = __webpack_require__(16);
            var classof = __webpack_require__(50);
            var $export = __webpack_require__(4);
            var isObject = __webpack_require__(7);
            var aFunction = __webpack_require__(17);
            var anInstance = __webpack_require__(75);
            var forOf = __webpack_require__(76);
            var speciesConstructor = __webpack_require__(51);
            var task = __webpack_require__(52).set;
            var microtask = __webpack_require__(81)();
            var newPromiseCapabilityModule = __webpack_require__(32);
            var perform = __webpack_require__(53);
            var promiseResolve = __webpack_require__(54);
            var PROMISE = 'Promise';
            var TypeError = global.TypeError;
            var process = global.process;
            var $Promise = global[PROMISE];
            var isNode = classof(process) == 'process';
            var empty = function () { /* empty */ };
            var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
            var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;

            var USE_NATIVE = !!function () {
                try {
                    // correct subclassing with @@species support
                    var promise = $Promise.resolve(1);
                    var FakePromise = (promise.constructor = {})[__webpack_require__(1)('species')] = function (exec) {
                        exec(empty, empty);
                    };
                    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
                    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
                } catch (e) { /* empty */ }
            }();

// helpers
            var isThenable = function (it) {
                var then;
                return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
            };
            var notify = function (promise, isReject) {
                if (promise._n) return;
                promise._n = true;
                var chain = promise._c;
                microtask(function () {
                    var value = promise._v;
                    var ok = promise._s == 1;
                    var i = 0;
                    var run = function (reaction) {
                        var handler = ok ? reaction.ok : reaction.fail;
                        var resolve = reaction.resolve;
                        var reject = reaction.reject;
                        var domain = reaction.domain;
                        var result, then;
                        try {
                            if (handler) {
                                if (!ok) {
                                    if (promise._h == 2) onHandleUnhandled(promise);
                                    promise._h = 1;
                                }
                                if (handler === true) result = value;
                                else {
                                    if (domain) domain.enter();
                                    result = handler(value);
                                    if (domain) domain.exit();
                                }
                                if (result === reaction.promise) {
                                    reject(TypeError('Promise-chain cycle'));
                                } else if (then = isThenable(result)) {
                                    then.call(result, resolve, reject);
                                } else resolve(result);
                            } else reject(value);
                        } catch (e) {
                            reject(e);
                        }
                    };
                    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
                    promise._c = [];
                    promise._n = false;
                    if (isReject && !promise._h) onUnhandled(promise);
                });
            };
            var onUnhandled = function (promise) {
                task.call(global, function () {
                    var value = promise._v;
                    var unhandled = isUnhandled(promise);
                    var result, handler, console;
                    if (unhandled) {
                        result = perform(function () {
                            if (isNode) {
                                process.emit('unhandledRejection', value, promise);
                            } else if (handler = global.onunhandledrejection) {
                                handler({ promise: promise, reason: value });
                            } else if ((console = global.console) && console.error) {
                                console.error('Unhandled promise rejection', value);
                            }
                        });
                        // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
                        promise._h = isNode || isUnhandled(promise) ? 2 : 1;
                    } promise._a = undefined;
                    if (unhandled && result.e) throw result.v;
                });
            };
            var isUnhandled = function (promise) {
                return promise._h !== 1 && (promise._a || promise._c).length === 0;
            };
            var onHandleUnhandled = function (promise) {
                task.call(global, function () {
                    var handler;
                    if (isNode) {
                        process.emit('rejectionHandled', promise);
                    } else if (handler = global.onrejectionhandled) {
                        handler({ promise: promise, reason: promise._v });
                    }
                });
            };
            var $reject = function (value) {
                var promise = this;
                if (promise._d) return;
                promise._d = true;
                promise = promise._w || promise; // unwrap
                promise._v = value;
                promise._s = 2;
                if (!promise._a) promise._a = promise._c.slice();
                notify(promise, true);
            };
            var $resolve = function (value) {
                var promise = this;
                var then;
                if (promise._d) return;
                promise._d = true;
                promise = promise._w || promise; // unwrap
                try {
                    if (promise === value) throw TypeError("Promise can't be resolved itself");
                    if (then = isThenable(value)) {
                        microtask(function () {
                            var wrapper = { _w: promise, _d: false }; // wrap
                            try {
                                then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
                            } catch (e) {
                                $reject.call(wrapper, e);
                            }
                        });
                    } else {
                        promise._v = value;
                        promise._s = 1;
                        notify(promise, false);
                    }
                } catch (e) {
                    $reject.call({ _w: promise, _d: false }, e); // wrap
                }
            };

// constructor polyfill
            if (!USE_NATIVE) {
                // 25.4.3.1 Promise(executor)
                $Promise = function Promise(executor) {
                    anInstance(this, $Promise, PROMISE, '_h');
                    aFunction(executor);
                    Internal.call(this);
                    try {
                        executor(ctx($resolve, this, 1), ctx($reject, this, 1));
                    } catch (err) {
                        $reject.call(this, err);
                    }
                };
                // eslint-disable-next-line no-unused-vars
                Internal = function Promise(executor) {
                    this._c = [];             // <- awaiting reactions
                    this._a = undefined;      // <- checked in isUnhandled reactions
                    this._s = 0;              // <- state
                    this._d = false;          // <- done
                    this._v = undefined;      // <- value
                    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
                    this._n = false;          // <- notify
                };
                Internal.prototype = __webpack_require__(82)($Promise.prototype, {
                    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
                    then: function then(onFulfilled, onRejected) {
                        var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
                        reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
                        reaction.fail = typeof onRejected == 'function' && onRejected;
                        reaction.domain = isNode ? process.domain : undefined;
                        this._c.push(reaction);
                        if (this._a) this._a.push(reaction);
                        if (this._s) notify(this, false);
                        return reaction.promise;
                    },
                    // 25.4.5.1 Promise.prototype.catch(onRejected)
                    'catch': function (onRejected) {
                        return this.then(undefined, onRejected);
                    }
                });
                OwnPromiseCapability = function () {
                    var promise = new Internal();
                    this.promise = promise;
                    this.resolve = ctx($resolve, promise, 1);
                    this.reject = ctx($reject, promise, 1);
                };
                newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
                    return C === $Promise || C === Wrapper
                        ? new OwnPromiseCapability(C)
                        : newGenericPromiseCapability(C);
                };
            }

            $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
            __webpack_require__(22)($Promise, PROMISE);
            __webpack_require__(83)(PROMISE);
            Wrapper = __webpack_require__(2)[PROMISE];

// statics
            $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
                // 25.4.4.5 Promise.reject(r)
                reject: function reject(r) {
                    var capability = newPromiseCapability(this);
                    var $$reject = capability.reject;
                    $$reject(r);
                    return capability.promise;
                }
            });
            $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
                // 25.4.4.6 Promise.resolve(x)
                resolve: function resolve(x) {
                    return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
                }
            });
            $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(84)(function (iter) {
                    $Promise.all(iter)['catch'](empty);
                })), PROMISE, {
                // 25.4.4.1 Promise.all(iterable)
                all: function all(iterable) {
                    var C = this;
                    var capability = newPromiseCapability(C);
                    var resolve = capability.resolve;
                    var reject = capability.reject;
                    var result = perform(function () {
                        var values = [];
                        var index = 0;
                        var remaining = 1;
                        forOf(iterable, false, function (promise) {
                            var $index = index++;
                            var alreadyCalled = false;
                            values.push(undefined);
                            remaining++;
                            C.resolve(promise).then(function (value) {
                                if (alreadyCalled) return;
                                alreadyCalled = true;
                                values[$index] = value;
                                --remaining || resolve(values);
                            }, reject);
                        });
                        --remaining || resolve(values);
                    });
                    if (result.e) reject(result.v);
                    return capability.promise;
                },
                // 25.4.4.4 Promise.race(iterable)
                race: function race(iterable) {
                    var C = this;
                    var capability = newPromiseCapability(C);
                    var reject = capability.reject;
                    var result = perform(function () {
                        forOf(iterable, false, function (promise) {
                            C.resolve(promise).then(capability.resolve, reject);
                        });
                    });
                    if (result.e) reject(result.v);
                    return capability.promise;
                }
            });


            /***/ }),
        /* 75 */
        /***/ (function(module, exports) {

            module.exports = function (it, Constructor, name, forbiddenField) {
                if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
                    throw TypeError(name + ': incorrect invocation!');
                } return it;
            };


            /***/ }),
        /* 76 */
        /***/ (function(module, exports, __webpack_require__) {

            var ctx = __webpack_require__(16);
            var call = __webpack_require__(77);
            var isArrayIter = __webpack_require__(78);
            var anObject = __webpack_require__(3);
            var toLength = __webpack_require__(41);
            var getIterFn = __webpack_require__(79);
            var BREAK = {};
            var RETURN = {};
            var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
                var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
                var f = ctx(fn, that, entries ? 2 : 1);
                var index = 0;
                var length, step, iterator, result;
                if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
                // fast case for arrays with default iterator
                if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
                    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
                    if (result === BREAK || result === RETURN) return result;
                } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
                    result = call(iterator, f, step.value, entries);
                    if (result === BREAK || result === RETURN) return result;
                }
            };
            exports.BREAK = BREAK;
            exports.RETURN = RETURN;


            /***/ }),
        /* 77 */
        /***/ (function(module, exports, __webpack_require__) {

// call something on iterator step with safe closing on error
            var anObject = __webpack_require__(3);
            module.exports = function (iterator, fn, value, entries) {
                try {
                    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
                    // 7.4.6 IteratorClose(iterator, completion)
                } catch (e) {
                    var ret = iterator['return'];
                    if (ret !== undefined) anObject(ret.call(iterator));
                    throw e;
                }
            };


            /***/ }),
        /* 78 */
        /***/ (function(module, exports, __webpack_require__) {

// check on default Array iterator
            var Iterators = __webpack_require__(14);
            var ITERATOR = __webpack_require__(1)('iterator');
            var ArrayProto = Array.prototype;

            module.exports = function (it) {
                return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
            };


            /***/ }),
        /* 79 */
        /***/ (function(module, exports, __webpack_require__) {

            var classof = __webpack_require__(50);
            var ITERATOR = __webpack_require__(1)('iterator');
            var Iterators = __webpack_require__(14);
            module.exports = __webpack_require__(2).getIteratorMethod = function (it) {
                if (it != undefined) return it[ITERATOR]
                    || it['@@iterator']
                    || Iterators[classof(it)];
            };


            /***/ }),
        /* 80 */
        /***/ (function(module, exports) {

// fast apply, http://jsperf.lnkit.com/fast-apply/5
            module.exports = function (fn, args, that) {
                var un = that === undefined;
                switch (args.length) {
                    case 0: return un ? fn()
                        : fn.call(that);
                    case 1: return un ? fn(args[0])
                        : fn.call(that, args[0]);
                    case 2: return un ? fn(args[0], args[1])
                        : fn.call(that, args[0], args[1]);
                    case 3: return un ? fn(args[0], args[1], args[2])
                        : fn.call(that, args[0], args[1], args[2]);
                    case 4: return un ? fn(args[0], args[1], args[2], args[3])
                        : fn.call(that, args[0], args[1], args[2], args[3]);
                } return fn.apply(that, args);
            };


            /***/ }),
        /* 81 */
        /***/ (function(module, exports, __webpack_require__) {

            var global = __webpack_require__(0);
            var macrotask = __webpack_require__(52).set;
            var Observer = global.MutationObserver || global.WebKitMutationObserver;
            var process = global.process;
            var Promise = global.Promise;
            var isNode = __webpack_require__(13)(process) == 'process';

            module.exports = function () {
                var head, last, notify;

                var flush = function () {
                    var parent, fn;
                    if (isNode && (parent = process.domain)) parent.exit();
                    while (head) {
                        fn = head.fn;
                        head = head.next;
                        try {
                            fn();
                        } catch (e) {
                            if (head) notify();
                            else last = undefined;
                            throw e;
                        }
                    } last = undefined;
                    if (parent) parent.enter();
                };

                // Node.js
                if (isNode) {
                    notify = function () {
                        process.nextTick(flush);
                    };
                    // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
                } else if (Observer && !(global.navigator && global.navigator.standalone)) {
                    var toggle = true;
                    var node = document.createTextNode('');
                    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
                    notify = function () {
                        node.data = toggle = !toggle;
                    };
                    // environments with maybe non-completely correct, but existent Promise
                } else if (Promise && Promise.resolve) {
                    var promise = Promise.resolve();
                    notify = function () {
                        promise.then(flush);
                    };
                    // for other environments - macrotask based on:
                    // - setImmediate
                    // - MessageChannel
                    // - window.postMessag
                    // - onreadystatechange
                    // - setTimeout
                } else {
                    notify = function () {
                        // strange IE + webpack dev server bug - use .call(global)
                        macrotask.call(global, flush);
                    };
                }

                return function (fn) {
                    var task = { fn: fn, next: undefined };
                    if (last) last.next = task;
                    if (!head) {
                        head = task;
                        notify();
                    } last = task;
                };
            };


            /***/ }),
        /* 82 */
        /***/ (function(module, exports, __webpack_require__) {

            var hide = __webpack_require__(5);
            module.exports = function (target, src, safe) {
                for (var key in src) {
                    if (safe && target[key]) target[key] = src[key];
                    else hide(target, key, src[key]);
                } return target;
            };


            /***/ }),
        /* 83 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

            var global = __webpack_require__(0);
            var core = __webpack_require__(2);
            var dP = __webpack_require__(6);
            var DESCRIPTORS = __webpack_require__(8);
            var SPECIES = __webpack_require__(1)('species');

            module.exports = function (KEY) {
                var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
                if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
                    configurable: true,
                    get: function () { return this; }
                });
            };


            /***/ }),
        /* 84 */
        /***/ (function(module, exports, __webpack_require__) {

            var ITERATOR = __webpack_require__(1)('iterator');
            var SAFE_CLOSING = false;

            try {
                var riter = [7][ITERATOR]();
                riter['return'] = function () { SAFE_CLOSING = true; };
                // eslint-disable-next-line no-throw-literal
                Array.from(riter, function () { throw 2; });
            } catch (e) { /* empty */ }

            module.exports = function (exec, skipClosing) {
                if (!skipClosing && !SAFE_CLOSING) return false;
                var safe = false;
                try {
                    var arr = [7];
                    var iter = arr[ITERATOR]();
                    iter.next = function () { return { done: safe = true }; };
                    arr[ITERATOR] = function () { return iter; };
                    exec(arr);
                } catch (e) { /* empty */ }
                return safe;
            };


            /***/ }),
        /* 85 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";
// https://github.com/tc39/proposal-promise-finally

            var $export = __webpack_require__(4);
            var core = __webpack_require__(2);
            var global = __webpack_require__(0);
            var speciesConstructor = __webpack_require__(51);
            var promiseResolve = __webpack_require__(54);

            $export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {
                var C = speciesConstructor(this, core.Promise || global.Promise);
                var isFunction = typeof onFinally == 'function';
                return this.then(
                    isFunction ? function (x) {
                        return promiseResolve(C, onFinally()).then(function () { return x; });
                    } : onFinally,
                    isFunction ? function (e) {
                        return promiseResolve(C, onFinally()).then(function () { throw e; });
                    } : onFinally
                );
            } });


            /***/ }),
        /* 86 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

// https://github.com/tc39/proposal-promise-try
            var $export = __webpack_require__(4);
            var newPromiseCapability = __webpack_require__(32);
            var perform = __webpack_require__(53);

            $export($export.S, 'Promise', { 'try': function (callbackfn) {
                var promiseCapability = newPromiseCapability.f(this);
                var result = perform(callbackfn);
                (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
                return promiseCapability.promise;
            } });


            /***/ }),
        /* 87 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(88);
            module.exports = __webpack_require__(2).Object.keys;


            /***/ }),
        /* 88 */
        /***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 Object.keys(O)
            var toObject = __webpack_require__(31);
            var $keys = __webpack_require__(12);

            __webpack_require__(89)('keys', function () {
                return function keys(it) {
                    return $keys(toObject(it));
                };
            });


            /***/ }),
        /* 89 */
        /***/ (function(module, exports, __webpack_require__) {

// most Object methods by ES6 should accept primitives
            var $export = __webpack_require__(4);
            var core = __webpack_require__(2);
            var fails = __webpack_require__(10);
            module.exports = function (KEY, exec) {
                var fn = (core.Object || {})[KEY] || Object[KEY];
                var exp = {};
                exp[KEY] = exec(fn);
                $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
            };


            /***/ }),
        /* 90 */
        /***/ (function(module, exports, __webpack_require__) {

            (function (factory) {
                if (true) {
                    // Node/CommonJS
                    module.exports = factory();
                } else if (typeof define === 'function' && define.amd) {
                    // AMD
                    define(factory);
                } else {
                    // Browser globals (with support for web workers)
                    var glob;

                    try {
                        glob = window;
                    } catch (e) {
                        glob = self;
                    }

                    glob.SparkMD5 = factory();
                }
            }(function (undefined) {

                'use strict';

                /*
                 * Fastest md5 implementation around (JKM md5).
                 * Credits: Joseph Myers
                 *
                 * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
                 * @see http://jsperf.com/md5-shootout/7
                 */

                /* this function is much faster,
                 so if possible we use it. Some IEs
                 are the only ones I know of that
                 need the idiotic second function,
                 generated by an if clause.  */
                var add32 = function (a, b) {
                        return (a + b) & 0xFFFFFFFF;
                    },
                    hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];


                function cmn(q, a, b, x, s, t) {
                    a = add32(add32(a, q), add32(x, t));
                    return add32((a << s) | (a >>> (32 - s)), b);
                }

                function md5cycle(x, k) {
                    var a = x[0],
                        b = x[1],
                        c = x[2],
                        d = x[3];

                    a += (b & c | ~b & d) + k[0] - 680876936 | 0;
                    a  = (a << 7 | a >>> 25) + b | 0;
                    d += (a & b | ~a & c) + k[1] - 389564586 | 0;
                    d  = (d << 12 | d >>> 20) + a | 0;
                    c += (d & a | ~d & b) + k[2] + 606105819 | 0;
                    c  = (c << 17 | c >>> 15) + d | 0;
                    b += (c & d | ~c & a) + k[3] - 1044525330 | 0;
                    b  = (b << 22 | b >>> 10) + c | 0;
                    a += (b & c | ~b & d) + k[4] - 176418897 | 0;
                    a  = (a << 7 | a >>> 25) + b | 0;
                    d += (a & b | ~a & c) + k[5] + 1200080426 | 0;
                    d  = (d << 12 | d >>> 20) + a | 0;
                    c += (d & a | ~d & b) + k[6] - 1473231341 | 0;
                    c  = (c << 17 | c >>> 15) + d | 0;
                    b += (c & d | ~c & a) + k[7] - 45705983 | 0;
                    b  = (b << 22 | b >>> 10) + c | 0;
                    a += (b & c | ~b & d) + k[8] + 1770035416 | 0;
                    a  = (a << 7 | a >>> 25) + b | 0;
                    d += (a & b | ~a & c) + k[9] - 1958414417 | 0;
                    d  = (d << 12 | d >>> 20) + a | 0;
                    c += (d & a | ~d & b) + k[10] - 42063 | 0;
                    c  = (c << 17 | c >>> 15) + d | 0;
                    b += (c & d | ~c & a) + k[11] - 1990404162 | 0;
                    b  = (b << 22 | b >>> 10) + c | 0;
                    a += (b & c | ~b & d) + k[12] + 1804603682 | 0;
                    a  = (a << 7 | a >>> 25) + b | 0;
                    d += (a & b | ~a & c) + k[13] - 40341101 | 0;
                    d  = (d << 12 | d >>> 20) + a | 0;
                    c += (d & a | ~d & b) + k[14] - 1502002290 | 0;
                    c  = (c << 17 | c >>> 15) + d | 0;
                    b += (c & d | ~c & a) + k[15] + 1236535329 | 0;
                    b  = (b << 22 | b >>> 10) + c | 0;

                    a += (b & d | c & ~d) + k[1] - 165796510 | 0;
                    a  = (a << 5 | a >>> 27) + b | 0;
                    d += (a & c | b & ~c) + k[6] - 1069501632 | 0;
                    d  = (d << 9 | d >>> 23) + a | 0;
                    c += (d & b | a & ~b) + k[11] + 643717713 | 0;
                    c  = (c << 14 | c >>> 18) + d | 0;
                    b += (c & a | d & ~a) + k[0] - 373897302 | 0;
                    b  = (b << 20 | b >>> 12) + c | 0;
                    a += (b & d | c & ~d) + k[5] - 701558691 | 0;
                    a  = (a << 5 | a >>> 27) + b | 0;
                    d += (a & c | b & ~c) + k[10] + 38016083 | 0;
                    d  = (d << 9 | d >>> 23) + a | 0;
                    c += (d & b | a & ~b) + k[15] - 660478335 | 0;
                    c  = (c << 14 | c >>> 18) + d | 0;
                    b += (c & a | d & ~a) + k[4] - 405537848 | 0;
                    b  = (b << 20 | b >>> 12) + c | 0;
                    a += (b & d | c & ~d) + k[9] + 568446438 | 0;
                    a  = (a << 5 | a >>> 27) + b | 0;
                    d += (a & c | b & ~c) + k[14] - 1019803690 | 0;
                    d  = (d << 9 | d >>> 23) + a | 0;
                    c += (d & b | a & ~b) + k[3] - 187363961 | 0;
                    c  = (c << 14 | c >>> 18) + d | 0;
                    b += (c & a | d & ~a) + k[8] + 1163531501 | 0;
                    b  = (b << 20 | b >>> 12) + c | 0;
                    a += (b & d | c & ~d) + k[13] - 1444681467 | 0;
                    a  = (a << 5 | a >>> 27) + b | 0;
                    d += (a & c | b & ~c) + k[2] - 51403784 | 0;
                    d  = (d << 9 | d >>> 23) + a | 0;
                    c += (d & b | a & ~b) + k[7] + 1735328473 | 0;
                    c  = (c << 14 | c >>> 18) + d | 0;
                    b += (c & a | d & ~a) + k[12] - 1926607734 | 0;
                    b  = (b << 20 | b >>> 12) + c | 0;

                    a += (b ^ c ^ d) + k[5] - 378558 | 0;
                    a  = (a << 4 | a >>> 28) + b | 0;
                    d += (a ^ b ^ c) + k[8] - 2022574463 | 0;
                    d  = (d << 11 | d >>> 21) + a | 0;
                    c += (d ^ a ^ b) + k[11] + 1839030562 | 0;
                    c  = (c << 16 | c >>> 16) + d | 0;
                    b += (c ^ d ^ a) + k[14] - 35309556 | 0;
                    b  = (b << 23 | b >>> 9) + c | 0;
                    a += (b ^ c ^ d) + k[1] - 1530992060 | 0;
                    a  = (a << 4 | a >>> 28) + b | 0;
                    d += (a ^ b ^ c) + k[4] + 1272893353 | 0;
                    d  = (d << 11 | d >>> 21) + a | 0;
                    c += (d ^ a ^ b) + k[7] - 155497632 | 0;
                    c  = (c << 16 | c >>> 16) + d | 0;
                    b += (c ^ d ^ a) + k[10] - 1094730640 | 0;
                    b  = (b << 23 | b >>> 9) + c | 0;
                    a += (b ^ c ^ d) + k[13] + 681279174 | 0;
                    a  = (a << 4 | a >>> 28) + b | 0;
                    d += (a ^ b ^ c) + k[0] - 358537222 | 0;
                    d  = (d << 11 | d >>> 21) + a | 0;
                    c += (d ^ a ^ b) + k[3] - 722521979 | 0;
                    c  = (c << 16 | c >>> 16) + d | 0;
                    b += (c ^ d ^ a) + k[6] + 76029189 | 0;
                    b  = (b << 23 | b >>> 9) + c | 0;
                    a += (b ^ c ^ d) + k[9] - 640364487 | 0;
                    a  = (a << 4 | a >>> 28) + b | 0;
                    d += (a ^ b ^ c) + k[12] - 421815835 | 0;
                    d  = (d << 11 | d >>> 21) + a | 0;
                    c += (d ^ a ^ b) + k[15] + 530742520 | 0;
                    c  = (c << 16 | c >>> 16) + d | 0;
                    b += (c ^ d ^ a) + k[2] - 995338651 | 0;
                    b  = (b << 23 | b >>> 9) + c | 0;

                    a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;
                    a  = (a << 6 | a >>> 26) + b | 0;
                    d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;
                    d  = (d << 10 | d >>> 22) + a | 0;
                    c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;
                    c  = (c << 15 | c >>> 17) + d | 0;
                    b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;
                    b  = (b << 21 |b >>> 11) + c | 0;
                    a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;
                    a  = (a << 6 | a >>> 26) + b | 0;
                    d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;
                    d  = (d << 10 | d >>> 22) + a | 0;
                    c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;
                    c  = (c << 15 | c >>> 17) + d | 0;
                    b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;
                    b  = (b << 21 |b >>> 11) + c | 0;
                    a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;
                    a  = (a << 6 | a >>> 26) + b | 0;
                    d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;
                    d  = (d << 10 | d >>> 22) + a | 0;
                    c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;
                    c  = (c << 15 | c >>> 17) + d | 0;
                    b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;
                    b  = (b << 21 |b >>> 11) + c | 0;
                    a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;
                    a  = (a << 6 | a >>> 26) + b | 0;
                    d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;
                    d  = (d << 10 | d >>> 22) + a | 0;
                    c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;
                    c  = (c << 15 | c >>> 17) + d | 0;
                    b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;
                    b  = (b << 21 | b >>> 11) + c | 0;

                    x[0] = a + x[0] | 0;
                    x[1] = b + x[1] | 0;
                    x[2] = c + x[2] | 0;
                    x[3] = d + x[3] | 0;
                }

                function md5blk(s) {
                    var md5blks = [],
                        i; /* Andy King said do it this way. */

                    for (i = 0; i < 64; i += 4) {
                        md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
                    }
                    return md5blks;
                }

                function md5blk_array(a) {
                    var md5blks = [],
                        i; /* Andy King said do it this way. */

                    for (i = 0; i < 64; i += 4) {
                        md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
                    }
                    return md5blks;
                }

                function md51(s) {
                    var n = s.length,
                        state = [1732584193, -271733879, -1732584194, 271733878],
                        i,
                        length,
                        tail,
                        tmp,
                        lo,
                        hi;

                    for (i = 64; i <= n; i += 64) {
                        md5cycle(state, md5blk(s.substring(i - 64, i)));
                    }
                    s = s.substring(i - 64);
                    length = s.length;
                    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                    for (i = 0; i < length; i += 1) {
                        tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
                    }
                    tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                    if (i > 55) {
                        md5cycle(state, tail);
                        for (i = 0; i < 16; i += 1) {
                            tail[i] = 0;
                        }
                    }

                    // Beware that the final length might not fit in 32 bits so we take care of that
                    tmp = n * 8;
                    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                    lo = parseInt(tmp[2], 16);
                    hi = parseInt(tmp[1], 16) || 0;

                    tail[14] = lo;
                    tail[15] = hi;

                    md5cycle(state, tail);
                    return state;
                }

                function md51_array(a) {
                    var n = a.length,
                        state = [1732584193, -271733879, -1732584194, 271733878],
                        i,
                        length,
                        tail,
                        tmp,
                        lo,
                        hi;

                    for (i = 64; i <= n; i += 64) {
                        md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
                    }

                    // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
                    // containing the last element of the parent array if the sub array specified starts
                    // beyond the length of the parent array - weird.
                    // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
                    a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);

                    length = a.length;
                    tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
                    for (i = 0; i < length; i += 1) {
                        tail[i >> 2] |= a[i] << ((i % 4) << 3);
                    }

                    tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                    if (i > 55) {
                        md5cycle(state, tail);
                        for (i = 0; i < 16; i += 1) {
                            tail[i] = 0;
                        }
                    }

                    // Beware that the final length might not fit in 32 bits so we take care of that
                    tmp = n * 8;
                    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                    lo = parseInt(tmp[2], 16);
                    hi = parseInt(tmp[1], 16) || 0;

                    tail[14] = lo;
                    tail[15] = hi;

                    md5cycle(state, tail);

                    return state;
                }

                function rhex(n) {
                    var s = '',
                        j;
                    for (j = 0; j < 4; j += 1) {
                        s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
                    }
                    return s;
                }

                function hex(x) {
                    var i;
                    for (i = 0; i < x.length; i += 1) {
                        x[i] = rhex(x[i]);
                    }
                    return x.join('');
                }

                // In some cases the fast add32 function cannot be used..
                if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {
                    add32 = function (x, y) {
                        var lsw = (x & 0xFFFF) + (y & 0xFFFF),
                            msw = (x >> 16) + (y >> 16) + (lsw >> 16);
                        return (msw << 16) | (lsw & 0xFFFF);
                    };
                }

                // ---------------------------------------------------

                /**
                 * ArrayBuffer slice polyfill.
                 *
                 * @see https://github.com/ttaubert/node-arraybuffer-slice
                 */

                if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {
                    (function () {
                        function clamp(val, length) {
                            val = (val | 0) || 0;

                            if (val < 0) {
                                return Math.max(val + length, 0);
                            }

                            return Math.min(val, length);
                        }

                        ArrayBuffer.prototype.slice = function (from, to) {
                            var length = this.byteLength,
                                begin = clamp(from, length),
                                end = length,
                                num,
                                target,
                                targetArray,
                                sourceArray;

                            if (to !== undefined) {
                                end = clamp(to, length);
                            }

                            if (begin > end) {
                                return new ArrayBuffer(0);
                            }

                            num = end - begin;
                            target = new ArrayBuffer(num);
                            targetArray = new Uint8Array(target);

                            sourceArray = new Uint8Array(this, begin, num);
                            targetArray.set(sourceArray);

                            return target;
                        };
                    })();
                }

                // ---------------------------------------------------

                /**
                 * Helpers.
                 */

                function toUtf8(str) {
                    if (/[\u0080-\uFFFF]/.test(str)) {
                        str = unescape(encodeURIComponent(str));
                    }

                    return str;
                }

                function utf8Str2ArrayBuffer(str, returnUInt8Array) {
                    var length = str.length,
                        buff = new ArrayBuffer(length),
                        arr = new Uint8Array(buff),
                        i;

                    for (i = 0; i < length; i += 1) {
                        arr[i] = str.charCodeAt(i);
                    }

                    return returnUInt8Array ? arr : buff;
                }

                function arrayBuffer2Utf8Str(buff) {
                    return String.fromCharCode.apply(null, new Uint8Array(buff));
                }

                function concatenateArrayBuffers(first, second, returnUInt8Array) {
                    var result = new Uint8Array(first.byteLength + second.byteLength);

                    result.set(new Uint8Array(first));
                    result.set(new Uint8Array(second), first.byteLength);

                    return returnUInt8Array ? result : result.buffer;
                }

                function hexToBinaryString(hex) {
                    var bytes = [],
                        length = hex.length,
                        x;

                    for (x = 0; x < length - 1; x += 2) {
                        bytes.push(parseInt(hex.substr(x, 2), 16));
                    }

                    return String.fromCharCode.apply(String, bytes);
                }

                // ---------------------------------------------------

                /**
                 * SparkMD5 OOP implementation.
                 *
                 * Use this class to perform an incremental md5, otherwise use the
                 * static methods instead.
                 */

                function SparkMD5() {
                    // call reset to init the instance
                    this.reset();
                }

                /**
                 * Appends a string.
                 * A conversion will be applied if an utf8 string is detected.
                 *
                 * @param {String} str The string to be appended
                 *
                 * @return {SparkMD5} The instance itself
                 */
                SparkMD5.prototype.append = function (str) {
                    // Converts the string to utf8 bytes if necessary
                    // Then append as binary
                    this.appendBinary(toUtf8(str));

                    return this;
                };

                /**
                 * Appends a binary string.
                 *
                 * @param {String} contents The binary string to be appended
                 *
                 * @return {SparkMD5} The instance itself
                 */
                SparkMD5.prototype.appendBinary = function (contents) {
                    this._buff += contents;
                    this._length += contents.length;

                    var length = this._buff.length,
                        i;

                    for (i = 64; i <= length; i += 64) {
                        md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));
                    }

                    this._buff = this._buff.substring(i - 64);

                    return this;
                };

                /**
                 * Finishes the incremental computation, reseting the internal state and
                 * returning the result.
                 *
                 * @param {Boolean} raw True to get the raw string, false to get the hex string
                 *
                 * @return {String} The result
                 */
                SparkMD5.prototype.end = function (raw) {
                    var buff = this._buff,
                        length = buff.length,
                        i,
                        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                        ret;

                    for (i = 0; i < length; i += 1) {
                        tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
                    }

                    this._finish(tail, length);
                    ret = hex(this._hash);

                    if (raw) {
                        ret = hexToBinaryString(ret);
                    }

                    this.reset();

                    return ret;
                };

                /**
                 * Resets the internal state of the computation.
                 *
                 * @return {SparkMD5} The instance itself
                 */
                SparkMD5.prototype.reset = function () {
                    this._buff = '';
                    this._length = 0;
                    this._hash = [1732584193, -271733879, -1732584194, 271733878];

                    return this;
                };

                /**
                 * Gets the internal state of the computation.
                 *
                 * @return {Object} The state
                 */
                SparkMD5.prototype.getState = function () {
                    return {
                        buff: this._buff,
                        length: this._length,
                        hash: this._hash
                    };
                };

                /**
                 * Gets the internal state of the computation.
                 *
                 * @param {Object} state The state
                 *
                 * @return {SparkMD5} The instance itself
                 */
                SparkMD5.prototype.setState = function (state) {
                    this._buff = state.buff;
                    this._length = state.length;
                    this._hash = state.hash;

                    return this;
                };

                /**
                 * Releases memory used by the incremental buffer and other additional
                 * resources. If you plan to use the instance again, use reset instead.
                 */
                SparkMD5.prototype.destroy = function () {
                    delete this._hash;
                    delete this._buff;
                    delete this._length;
                };

                /**
                 * Finish the final calculation based on the tail.
                 *
                 * @param {Array}  tail   The tail (will be modified)
                 * @param {Number} length The length of the remaining buffer
                 */
                SparkMD5.prototype._finish = function (tail, length) {
                    var i = length,
                        tmp,
                        lo,
                        hi;

                    tail[i >> 2] |= 0x80 << ((i % 4) << 3);
                    if (i > 55) {
                        md5cycle(this._hash, tail);
                        for (i = 0; i < 16; i += 1) {
                            tail[i] = 0;
                        }
                    }

                    // Do the final computation based on the tail and length
                    // Beware that the final length may not fit in 32 bits so we take care of that
                    tmp = this._length * 8;
                    tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
                    lo = parseInt(tmp[2], 16);
                    hi = parseInt(tmp[1], 16) || 0;

                    tail[14] = lo;
                    tail[15] = hi;
                    md5cycle(this._hash, tail);
                };

                /**
                 * Performs the md5 hash on a string.
                 * A conversion will be applied if utf8 string is detected.
                 *
                 * @param {String}  str The string
                 * @param {Boolean} raw True to get the raw string, false to get the hex string
                 *
                 * @return {String} The result
                 */
                SparkMD5.hash = function (str, raw) {
                    // Converts the string to utf8 bytes if necessary
                    // Then compute it using the binary function
                    return SparkMD5.hashBinary(toUtf8(str), raw);
                };

                /**
                 * Performs the md5 hash on a binary string.
                 *
                 * @param {String}  content The binary string
                 * @param {Boolean} raw     True to get the raw string, false to get the hex string
                 *
                 * @return {String} The result
                 */
                SparkMD5.hashBinary = function (content, raw) {
                    var hash = md51(content),
                        ret = hex(hash);

                    return raw ? hexToBinaryString(ret) : ret;
                };

                // ---------------------------------------------------

                /**
                 * SparkMD5 OOP implementation for array buffers.
                 *
                 * Use this class to perform an incremental md5 ONLY for array buffers.
                 */
                SparkMD5.ArrayBuffer = function () {
                    // call reset to init the instance
                    this.reset();
                };

                /**
                 * Appends an array buffer.
                 *
                 * @param {ArrayBuffer} arr The array to be appended
                 *
                 * @return {SparkMD5.ArrayBuffer} The instance itself
                 */
                SparkMD5.ArrayBuffer.prototype.append = function (arr) {
                    var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),
                        length = buff.length,
                        i;

                    this._length += arr.byteLength;

                    for (i = 64; i <= length; i += 64) {
                        md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));
                    }

                    this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);

                    return this;
                };

                /**
                 * Finishes the incremental computation, reseting the internal state and
                 * returning the result.
                 *
                 * @param {Boolean} raw True to get the raw string, false to get the hex string
                 *
                 * @return {String} The result
                 */
                SparkMD5.ArrayBuffer.prototype.end = function (raw) {
                    var buff = this._buff,
                        length = buff.length,
                        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                        i,
                        ret;

                    for (i = 0; i < length; i += 1) {
                        tail[i >> 2] |= buff[i] << ((i % 4) << 3);
                    }

                    this._finish(tail, length);
                    ret = hex(this._hash);

                    if (raw) {
                        ret = hexToBinaryString(ret);
                    }

                    this.reset();

                    return ret;
                };

                /**
                 * Resets the internal state of the computation.
                 *
                 * @return {SparkMD5.ArrayBuffer} The instance itself
                 */
                SparkMD5.ArrayBuffer.prototype.reset = function () {
                    this._buff = new Uint8Array(0);
                    this._length = 0;
                    this._hash = [1732584193, -271733879, -1732584194, 271733878];

                    return this;
                };

                /**
                 * Gets the internal state of the computation.
                 *
                 * @return {Object} The state
                 */
                SparkMD5.ArrayBuffer.prototype.getState = function () {
                    var state = SparkMD5.prototype.getState.call(this);

                    // Convert buffer to a string
                    state.buff = arrayBuffer2Utf8Str(state.buff);

                    return state;
                };

                /**
                 * Gets the internal state of the computation.
                 *
                 * @param {Object} state The state
                 *
                 * @return {SparkMD5.ArrayBuffer} The instance itself
                 */
                SparkMD5.ArrayBuffer.prototype.setState = function (state) {
                    // Convert string to buffer
                    state.buff = utf8Str2ArrayBuffer(state.buff, true);

                    return SparkMD5.prototype.setState.call(this, state);
                };

                SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;

                SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;

                /**
                 * Performs the md5 hash on an array buffer.
                 *
                 * @param {ArrayBuffer} arr The array buffer
                 * @param {Boolean}     raw True to get the raw string, false to get the hex one
                 *
                 * @return {String} The result
                 */
                SparkMD5.ArrayBuffer.hash = function (arr, raw) {
                    var hash = md51_array(new Uint8Array(arr)),
                        ret = hex(hash);

                    return raw ? hexToBinaryString(ret) : ret;
                };

                return SparkMD5;
            }));


            /***/ }),
        /* 91 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.UploadManager = undefined;

            var _promise = __webpack_require__(42);

            var _promise2 = _interopRequireDefault(_promise);

            var _assign = __webpack_require__(37);

            var _assign2 = _interopRequireDefault(_assign);

            var _classCallCheck2 = __webpack_require__(33);

            var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

            var _utils = __webpack_require__(15);

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            var BLOCK_SIZE = 4 * 1024 * 1024;

            var UploadManager = exports.UploadManager = function () {
                function UploadManager(options, handlers, statisticsLogger) {
                    var _this = this;

                    (0, _classCallCheck3["default"])(this, UploadManager);

                    this.config = (0, _assign2["default"])({
                        useCdnDomain: true,
                        disableStatisticsReport: false,
                        region: null
                    }, options.config);
                    this.putExtra = (0, _assign2["default"])({
                        fname: "",
                        params: {},
                        mimeType: null
                    }, options.putExtra);
                    this.statisticsLogger = statisticsLogger;
                    this.progress = null;
                    this.xhrList = [];
                    this.xhrHandler = function (xhr) {
                        return _this.xhrList.push(xhr);
                    };
                    this.file = options.file;
                    this.key = options.key;
                    this.token = options.token;
                    this.onData = function () {};
                    this.onError = function () {};
                    this.onComplete = function () {};
                    (0, _assign2["default"])(this, handlers);
                }

                UploadManager.prototype.putFile = function putFile() {
                    var _this2 = this;

                    if (!this.putExtra.fname) {
                        this.putExtra.fname = this.file.name;
                    }
                    if (this.putExtra.mimeType && this.putExtra.mimeType.length) {
                        if (!(0, _utils.isContainFileMimeType)(this.file.type, this.putExtra.mimeType)) {
                            var err = new Error("file type doesn't match with what you specify");
                            this.onError(err);
                            return _promise2["default"].reject(err);
                        }
                    }

                    this.uploadUrl = (0, _utils.getUploadUrl)(this.config);
                    this.uploadAt = new Date().getTime();

                    var upload = this.file.size > BLOCK_SIZE ? this.resumeUpload() : this.directUpload();
                    upload.then(function (res) {
                        _this2.onComplete(res.data);
                        if (!_this2.config.disableStatisticsReport) {
                            _this2.sendLog(res.reqId, 200);
                        }
                    }, function (err) {
                        _this2.onError(err);
                        if (err.isRequestError && !_this2.config.disableStatisticsReport) {
                            if (err.code !== 0) {
                                _this2.sendLog(err.reqId, err.code);
                            } else {
                                _this2.sendLog("", -2);
                            }
                        }
                        _this2.stop();
                    });
                    return upload;
                };

                UploadManager.prototype.stop = function stop() {
                    this.xhrList.forEach(function (xhr) {
                        return xhr.abort();
                    });
                    this.xhrList = [];
                };

                UploadManager.prototype.sendLog = function sendLog(reqId, code) {
                    this.statisticsLogger.log({
                        code: code,
                        reqId: reqId,
                        host: (0, _utils.getDomainFromUrl)(this.uploadUrl),
                        remoteIp: "",
                        port: (0, _utils.getPortFromUrl)(this.uploadUrl),
                        duration: (new Date().getTime() - this.uploadAt) / 1000,
                        time: Math.floor(this.uploadAt / 1000),
                        bytesSent: this.progress ? this.progress.total.loaded : 0,
                        upType: "jssdk-h5",
                        size: this.file.size
                    }, this.token);
                };

                // 直传


                UploadManager.prototype.directUpload = function directUpload() {
                    var _this3 = this;

                    var formData = new FormData();
                    formData.append("file", this.file);
                    formData.append("token", this.token);
                    if (this.key != null) {
                        formData.append("key", this.key);
                    }
                    formData.append("fname", this.putExtra.fname);
                    (0, _utils.filterParams)(this.putExtra.params).forEach(function (item) {
                        return formData.append(item[0], item[1]);
                    });

                    return (0, _utils.request)(this.uploadUrl, {
                        method: "POST",
                        body: formData,
                        onProgress: function onProgress(data) {
                            _this3.updateDirectProgress(data.loaded, data.total);
                        },
                        onCreate: this.xhrHandler
                    });
                };

                // 分片上传


                UploadManager.prototype.resumeUpload = function resumeUpload() {
                    var _this4 = this;

                    this.loaded = {
                        mkFileProgress: 0,
                        chunks: null
                    };

                    return (0, _utils.getLocalFileInfoAndMd5)(this.file).then(function (res) {
                        _this4.ctxList = [];
                        var md5 = res.md5;
                        _this4.localInfo = res.info;

                        _this4.chunks = (0, _utils.getChunks)(_this4.file, BLOCK_SIZE);
                        _this4.initChunksProgress();
                        var uploadChunks = _this4.chunks.map(function (chunk, index) {
                            return _this4.uploadChunk(chunk, index);
                        });

                        var result = _promise2["default"].all(uploadChunks).then(function () {
                            return _this4.mkFileReq();
                        });

                        result.then(function (res) {
                            (0, _utils.removeLocalFileInfo)(_this4.file.name, md5);
                        }, function (err) {
                            // ctx错误或者过期情况下清除本地存储数据
                            err.code === 701 ? (0, _utils.removeLocalFileInfo)(_this4.file.name, md5) : (0, _utils.setLocalFileInfo)(_this4.file.name, md5, _this4.ctxList);
                        });
                        return result;
                    });
                };

                UploadManager.prototype.uploadChunk = function uploadChunk(chunk, index) {
                    var _this5 = this;

                    var info = this.localInfo[index];
                    if (info && !(0, _utils.isChunkExpired)(info.time)) {
                        this.updateChunkProgress(chunk.size, index);
                        this.ctxList[index] = { ctx: info.ctx, time: info.time };
                        return _promise2["default"].resolve();
                    }

                    var requestUrl = this.uploadUrl + "/mkblk/" + chunk.size;

                    return (0, _utils.readAsArrayBuffer)(chunk).then(function (body) {
                        var headers = (0, _utils.getHeadersForChunkUpload)(_this5.token);
                        var onProgress = function onProgress(data) {
                            _this5.updateChunkProgress(data.loaded, index);
                        };
                        var onCreate = _this5.xhrHandler;
                        var method = "POST";

                        return (0, _utils.request)(requestUrl, {
                            method: method,
                            headers: headers,
                            body: body,
                            onProgress: onProgress,
                            onCreate: onCreate
                        }).then(function (response) {
                            _this5.ctxList[index] = {
                                time: new Date().getTime(),
                                ctx: response.ctx
                            };
                        });
                    });
                };

                UploadManager.prototype.mkFileReq = function mkFileReq() {
                    var _this6 = this;

                    var putExtra = (0, _assign2["default"])({ mimeType: "application/octet-stream" }, this.putExtra);

                    var requestUrL = (0, _utils.createMkFileUrl)(this.uploadUrl, this.file.size, this.key, putExtra);

                    var body = this.ctxList.map(function (value) {
                        return value.ctx;
                    }).join(",");
                    var headers = (0, _utils.getHeadersForMkFile)(this.token);
                    var onCreate = this.xhrHandler;
                    var method = "POST";
                    return (0, _utils.request)(requestUrL, { method: method, body: body, headers: headers, onCreate: onCreate }).then(function (res) {
                        _this6.updateMkFileProgress(1);
                        return _promise2["default"].resolve(res);
                    });
                };

                UploadManager.prototype.updateDirectProgress = function updateDirectProgress(loaded, total) {
                    this.progress = { total: this.getProgressInfoItem(loaded, total) };
                    this.onData(this.progress);
                };

                UploadManager.prototype.initChunksProgress = function initChunksProgress() {
                    this.loaded.chunks = this.chunks.map(function (_) {
                        return 0;
                    });
                    this.notifyResumeProgress();
                };

                UploadManager.prototype.updateChunkProgress = function updateChunkProgress(loaded, index) {
                    this.loaded.chunks[index] = loaded;
                    this.notifyResumeProgress();
                };

                UploadManager.prototype.updateMkFileProgress = function updateMkFileProgress(progress) {
                    this.loaded.mkFileProgress = progress;
                    this.notifyResumeProgress();
                };

                UploadManager.prototype.notifyResumeProgress = function notifyResumeProgress() {
                    var _this7 = this;

                    this.progress = {
                        total: this.getProgressInfoItem((0, _utils.sum)(this.loaded.chunks) + this.loaded.mkFileProgress, this.file.size + 1),
                        chunks: this.chunks.map(function (chunk, index) {
                            return _this7.getProgressInfoItem(_this7.loaded.chunks[index], chunk.size);
                        })
                    };
                    this.onData(this.progress);
                };

                UploadManager.prototype.getProgressInfoItem = function getProgressInfoItem(loaded, size) {
                    return {
                        loaded: loaded,
                        size: size,
                        percent: loaded / size * 100
                    };
                };

                return UploadManager;
            }();

            /***/ }),
        /* 92 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.imageView2 = imageView2;
            exports.imageMogr2 = imageMogr2;
            exports.watermark = watermark;
            exports.imageInfo = imageInfo;
            exports.exif = exif;
            exports.pipeline = pipeline;

            var _utils = __webpack_require__(15);

            var _base = __webpack_require__(56);

            function getImageUrl(key, domain) {
                key = encodeURIComponent(key);
                if (domain.slice(domain.length - 1) !== "/") {
                    domain = domain + "/";
                }
                return domain + key;
            }

            function imageView2(op, key, domain) {
                if (!/^\d$/.test(op.mode)) {
                    throw "mode should be number in imageView2";
                }
                var mode = op.mode,
                    w = op.w,
                    h = op.h,
                    q = op.q,
                    format = op.format;

                if (!w && !h) {
                    throw "param w and h is empty in imageView2";
                }

                var imageUrl = "imageView2/" + encodeURIComponent(mode);
                imageUrl += w ? "/w/" + encodeURIComponent(w) : "";
                imageUrl += h ? "/h/" + encodeURIComponent(h) : "";
                imageUrl += q ? "/q/" + encodeURIComponent(q) : "";
                imageUrl += format ? "/format/" + encodeURIComponent(format) : "";
                if (key) {
                    imageUrl = getImageUrl(key, domain) + "?" + imageUrl;
                }
                return imageUrl;
            }

// invoke the imageMogr2 api of Qiniu

            function imageMogr2(op, key, domain) {
                var auto_orient = op["auto-orient"],
                    thumbnail = op.thumbnail,
                    strip = op.strip,
                    gravity = op.gravity,
                    crop = op.crop,
                    quality = op.quality,
                    rotate = op.rotate,
                    format = op.format,
                    blur = op.blur;

                var imageUrl = "imageMogr2";

                imageUrl += auto_orient ? "/auto-orient" : "";
                imageUrl += thumbnail ? "/thumbnail/" + encodeURIComponent(thumbnail) : "";
                imageUrl += strip ? "/strip" : "";
                imageUrl += gravity ? "/gravity/" + encodeURIComponent(gravity) : "";
                imageUrl += quality ? "/quality/" + encodeURIComponent(quality) : "";
                imageUrl += crop ? "/crop/" + encodeURIComponent(crop) : "";
                imageUrl += rotate ? "/rotate/" + encodeURIComponent(rotate) : "";
                imageUrl += format ? "/format/" + encodeURIComponent(format) : "";
                imageUrl += blur ? "/blur/" + encodeURIComponent(blur) : "";
                if (key) {
                    imageUrl = getImageUrl(key, domain) + "?" + imageUrl;
                }
                return imageUrl;
            }

// invoke the watermark api of Qiniu

            function watermark(op, key, domain) {
                var mode = op.mode;
                if (!mode) {
                    throw "mode can't be empty in watermark";
                }

                var imageUrl = "watermark/" + mode;
                if (mode !== 1 && mode !== 2) {
                    throw "mode is wrong";
                }

                if (mode === 1) {
                    var image = op.image;
                    if (!image) {
                        throw "image can't be empty in watermark";
                    }
                    imageUrl += image ? "/image/" + (0, _base.urlSafeBase64Encode)(image) : "";
                }

                if (mode === 2) {
                    var text = op.text,
                        font = op.font,
                        fontsize = op.fontsize,
                        fill = op.fill;
                    if (!text) {
                        throw "text can't be empty in watermark";
                    }
                    imageUrl += text ? "/text/" + (0, _base.urlSafeBase64Encode)(text) : "";
                    imageUrl += font ? "/font/" + (0, _base.urlSafeBase64Encode)(font) : "";
                    imageUrl += fontsize ? "/fontsize/" + fontsize : "";
                    imageUrl += fill ? "/fill/" + (0, _base.urlSafeBase64Encode)(fill) : "";
                }
                var dissolve = op.dissolve,
                    gravity = op.gravity,
                    dx = op.dx,
                    dy = op.dy;

                imageUrl += dissolve ? "/dissolve/" + encodeURIComponent(dissolve) : "";
                imageUrl += gravity ? "/gravity/" + encodeURIComponent(gravity) : "";
                imageUrl += dx ? "/dx/" + encodeURIComponent(dx) : "";
                imageUrl += dy ? "/dy/" + encodeURIComponent(dy) : "";
                if (key) {
                    imageUrl = getImageUrl(key, domain) + "?" + imageUrl;
                }
                return imageUrl;
            }

// invoke the imageInfo api of Qiniu
            function imageInfo(key, domain) {
                var url = getImageUrl(key, domain) + "?imageInfo";
                return (0, _utils.request)(url, { method: "GET" });
            }

// invoke the exif api of Qiniu
            function exif(key, domain) {
                var url = getImageUrl(key, domain) + "?exif";
                return (0, _utils.request)(url, { method: "GET" });
            }

            function pipeline(arr, key, domain) {
                var isArray = Object.prototype.toString.call(arr) === "[object Array]";
                var option = void 0,
                    errOp = void 0,
                    imageUrl = "";
                if (isArray) {
                    for (var i = 0, len = arr.length; i < len; i++) {
                        option = arr[i];
                        if (!option.fop) {
                            throw "fop can't be empty in pipeline";
                        }
                        switch (option.fop) {
                            case "watermark":
                                imageUrl += watermark(option) + "|";
                                break;
                            case "imageView2":
                                imageUrl += imageView2(option) + "|";
                                break;
                            case "imageMogr2":
                                imageUrl += imageMogr2(option) + "|";
                                break;
                            default:
                                errOp = true;
                                break;
                        }
                        if (errOp) {
                            throw "fop is wrong in pipeline";
                        }
                    }
                    if (key) {
                        imageUrl = getImageUrl(key, domain) + "?" + imageUrl;
                        var length = imageUrl.length;
                        if (imageUrl.slice(length - 1) === "|") {
                            imageUrl = imageUrl.slice(0, length - 1);
                        }
                    }
                    return imageUrl;
                }
                throw "pipeline's first param should be array";
            }

            /***/ }),
        /* 93 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.Observable = undefined;

            var _typeof2 = __webpack_require__(94);

            var _typeof3 = _interopRequireDefault(_typeof2);

            var _classCallCheck2 = __webpack_require__(33);

            var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            var Observable = exports.Observable = function () {
                function Observable(subscribeAction) {
                    (0, _classCallCheck3["default"])(this, Observable);

                    this.subscribeAction = subscribeAction;
                }

                Observable.prototype.subscribe = function subscribe(oOrOnNext, onError, onCompleted) {
                    var observer = new Observer(oOrOnNext, onError, onCompleted);
                    var result = this.subscribeAction(observer); // 开始发射数据并拿到subscribeAction的返回值
                    return new Subscription(observer, result); // 创造控制observer和subscribeAction的实例对象
                };

                return Observable;
            }();

            var Observer = function () {
                function Observer(onNext, onError, onCompleted) {
                    (0, _classCallCheck3["default"])(this, Observer);

                    this.isStopped = false;
                    if ((typeof onNext === "undefined" ? "undefined" : (0, _typeof3["default"])(onNext)) === "object") {
                        this._onNext = onNext.next;
                        this._onError = onNext.error;
                        this._onCompleted = onNext.complete;
                    } else {
                        this._onNext = onNext;
                        this._onError = onError;
                        this._onCompleted = onCompleted;
                    }
                }

                Observer.prototype.next = function next(value) {
                    if (!this.isStopped && this._onNext) {
                        this._onNext(value);
                    }
                };

                Observer.prototype.error = function error(err) {
                    if (!this.isStopped && this._onError) {
                        this.isStopped = true;
                        this._onError(err);
                    }
                };

                Observer.prototype.complete = function complete(res) {
                    if (!this.isStopped && this._onCompleted) {
                        this.isStopped = true;
                        this._onCompleted(res);
                    }
                };

                return Observer;
            }();

            var Subscription = function () {
                function Subscription(observer, result) {
                    (0, _classCallCheck3["default"])(this, Subscription);

                    this.observer = observer;
                    this.result = result;
                }

                Subscription.prototype.unsubscribe = function unsubscribe() {
                    this.observer.isStopped = true; // 取消observer的订阅
                    this.result();
                };

                return Subscription;
            }();

            /***/ }),
        /* 94 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;

            var _iterator = __webpack_require__(95);

            var _iterator2 = _interopRequireDefault(_iterator);

            var _symbol = __webpack_require__(97);

            var _symbol2 = _interopRequireDefault(_symbol);

            var _typeof = typeof _symbol2["default"] === "function" && typeof _iterator2["default"] === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2["default"] === "function" && obj.constructor === _symbol2["default"] && obj !== _symbol2["default"].prototype ? "symbol" : typeof obj; };

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            exports["default"] = typeof _symbol2["default"] === "function" && _typeof(_iterator2["default"]) === "symbol" ? function (obj) {
                return typeof obj === "undefined" ? "undefined" : _typeof(obj);
            } : function (obj) {
                return obj && typeof _symbol2["default"] === "function" && obj.constructor === _symbol2["default"] && obj !== _symbol2["default"].prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
            };

            /***/ }),
        /* 95 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(96), __esModule: true };

            /***/ }),
        /* 96 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(44);
            __webpack_require__(49);
            module.exports = __webpack_require__(34).f('iterator');


            /***/ }),
        /* 97 */
        /***/ (function(module, exports, __webpack_require__) {

            module.exports = { "default": __webpack_require__(98), __esModule: true };

            /***/ }),
        /* 98 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(99);
            __webpack_require__(43);
            __webpack_require__(105);
            __webpack_require__(106);
            module.exports = __webpack_require__(2).Symbol;


            /***/ }),
        /* 99 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";

// ECMAScript 6 symbols shim
            var global = __webpack_require__(0);
            var has = __webpack_require__(9);
            var DESCRIPTORS = __webpack_require__(8);
            var $export = __webpack_require__(4);
            var redefine = __webpack_require__(46);
            var META = __webpack_require__(100).KEY;
            var $fails = __webpack_require__(10);
            var shared = __webpack_require__(28);
            var setToStringTag = __webpack_require__(22);
            var uid = __webpack_require__(19);
            var wks = __webpack_require__(1);
            var wksExt = __webpack_require__(34);
            var wksDefine = __webpack_require__(35);
            var enumKeys = __webpack_require__(101);
            var isArray = __webpack_require__(102);
            var anObject = __webpack_require__(3);
            var isObject = __webpack_require__(7);
            var toIObject = __webpack_require__(11);
            var toPrimitive = __webpack_require__(24);
            var createDesc = __webpack_require__(18);
            var _create = __webpack_require__(47);
            var gOPNExt = __webpack_require__(103);
            var $GOPD = __webpack_require__(104);
            var $DP = __webpack_require__(6);
            var $keys = __webpack_require__(12);
            var gOPD = $GOPD.f;
            var dP = $DP.f;
            var gOPN = gOPNExt.f;
            var $Symbol = global.Symbol;
            var $JSON = global.JSON;
            var _stringify = $JSON && $JSON.stringify;
            var PROTOTYPE = 'prototype';
            var HIDDEN = wks('_hidden');
            var TO_PRIMITIVE = wks('toPrimitive');
            var isEnum = {}.propertyIsEnumerable;
            var SymbolRegistry = shared('symbol-registry');
            var AllSymbols = shared('symbols');
            var OPSymbols = shared('op-symbols');
            var ObjectProto = Object[PROTOTYPE];
            var USE_NATIVE = typeof $Symbol == 'function';
            var QObject = global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
            var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
            var setSymbolDesc = DESCRIPTORS && $fails(function () {
                return _create(dP({}, 'a', {
                        get: function () { return dP(this, 'a', { value: 7 }).a; }
                    })).a != 7;
            }) ? function (it, key, D) {
                var protoDesc = gOPD(ObjectProto, key);
                if (protoDesc) delete ObjectProto[key];
                dP(it, key, D);
                if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
            } : dP;

            var wrap = function (tag) {
                var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
                sym._k = tag;
                return sym;
            };

            var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
                return typeof it == 'symbol';
            } : function (it) {
                return it instanceof $Symbol;
            };

            var $defineProperty = function defineProperty(it, key, D) {
                if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
                anObject(it);
                key = toPrimitive(key, true);
                anObject(D);
                if (has(AllSymbols, key)) {
                    if (!D.enumerable) {
                        if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
                        it[HIDDEN][key] = true;
                    } else {
                        if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
                        D = _create(D, { enumerable: createDesc(0, false) });
                    } return setSymbolDesc(it, key, D);
                } return dP(it, key, D);
            };
            var $defineProperties = function defineProperties(it, P) {
                anObject(it);
                var keys = enumKeys(P = toIObject(P));
                var i = 0;
                var l = keys.length;
                var key;
                while (l > i) $defineProperty(it, key = keys[i++], P[key]);
                return it;
            };
            var $create = function create(it, P) {
                return P === undefined ? _create(it) : $defineProperties(_create(it), P);
            };
            var $propertyIsEnumerable = function propertyIsEnumerable(key) {
                var E = isEnum.call(this, key = toPrimitive(key, true));
                if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
                return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
            };
            var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
                it = toIObject(it);
                key = toPrimitive(key, true);
                if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
                var D = gOPD(it, key);
                if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
                return D;
            };
            var $getOwnPropertyNames = function getOwnPropertyNames(it) {
                var names = gOPN(toIObject(it));
                var result = [];
                var i = 0;
                var key;
                while (names.length > i) {
                    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
                } return result;
            };
            var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
                var IS_OP = it === ObjectProto;
                var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
                var result = [];
                var i = 0;
                var key;
                while (names.length > i) {
                    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
                } return result;
            };

// 19.4.1.1 Symbol([description])
            if (!USE_NATIVE) {
                $Symbol = function Symbol() {
                    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
                    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
                    var $set = function (value) {
                        if (this === ObjectProto) $set.call(OPSymbols, value);
                        if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
                        setSymbolDesc(this, tag, createDesc(1, value));
                    };
                    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
                    return wrap(tag);
                };
                redefine($Symbol[PROTOTYPE], 'toString', function toString() {
                    return this._k;
                });

                $GOPD.f = $getOwnPropertyDescriptor;
                $DP.f = $defineProperty;
                __webpack_require__(57).f = gOPNExt.f = $getOwnPropertyNames;
                __webpack_require__(20).f = $propertyIsEnumerable;
                __webpack_require__(30).f = $getOwnPropertySymbols;

                if (DESCRIPTORS && !__webpack_require__(21)) {
                    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
                }

                wksExt.f = function (name) {
                    return wrap(wks(name));
                };
            }

            $export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });

            for (var es6Symbols = (
                // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
                'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
            ).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);

            for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);

            $export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
                // 19.4.2.1 Symbol.for(key)
                'for': function (key) {
                    return has(SymbolRegistry, key += '')
                        ? SymbolRegistry[key]
                        : SymbolRegistry[key] = $Symbol(key);
                },
                // 19.4.2.5 Symbol.keyFor(sym)
                keyFor: function keyFor(sym) {
                    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
                    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
                },
                useSetter: function () { setter = true; },
                useSimple: function () { setter = false; }
            });

            $export($export.S + $export.F * !USE_NATIVE, 'Object', {
                // 19.1.2.2 Object.create(O [, Properties])
                create: $create,
                // 19.1.2.4 Object.defineProperty(O, P, Attributes)
                defineProperty: $defineProperty,
                // 19.1.2.3 Object.defineProperties(O, Properties)
                defineProperties: $defineProperties,
                // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
                getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
                // 19.1.2.7 Object.getOwnPropertyNames(O)
                getOwnPropertyNames: $getOwnPropertyNames,
                // 19.1.2.8 Object.getOwnPropertySymbols(O)
                getOwnPropertySymbols: $getOwnPropertySymbols
            });

// 24.3.2 JSON.stringify(value [, replacer [, space]])
            $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
                    var S = $Symbol();
                    // MS Edge converts symbol values to JSON as {}
                    // WebKit converts symbol values to JSON as null
                    // V8 throws on boxed symbols
                    return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
                })), 'JSON', {
                stringify: function stringify(it) {
                    var args = [it];
                    var i = 1;
                    var replacer, $replacer;
                    while (arguments.length > i) args.push(arguments[i++]);
                    $replacer = replacer = args[1];
                    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
                    if (!isArray(replacer)) replacer = function (key, value) {
                        if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
                        if (!isSymbol(value)) return value;
                    };
                    args[1] = replacer;
                    return _stringify.apply($JSON, args);
                }
            });

// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
            $Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(5)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
// 19.4.3.5 Symbol.prototype[@@toStringTag]
            setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
            setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
            setToStringTag(global.JSON, 'JSON', true);


            /***/ }),
        /* 100 */
        /***/ (function(module, exports, __webpack_require__) {

            var META = __webpack_require__(19)('meta');
            var isObject = __webpack_require__(7);
            var has = __webpack_require__(9);
            var setDesc = __webpack_require__(6).f;
            var id = 0;
            var isExtensible = Object.isExtensible || function () {
                    return true;
                };
            var FREEZE = !__webpack_require__(10)(function () {
                return isExtensible(Object.preventExtensions({}));
            });
            var setMeta = function (it) {
                setDesc(it, META, { value: {
                    i: 'O' + ++id, // object ID
                    w: {}          // weak collections IDs
                } });
            };
            var fastKey = function (it, create) {
                // return primitive with prefix
                if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
                if (!has(it, META)) {
                    // can't set metadata to uncaught frozen object
                    if (!isExtensible(it)) return 'F';
                    // not necessary to add metadata
                    if (!create) return 'E';
                    // add missing metadata
                    setMeta(it);
                    // return object ID
                } return it[META].i;
            };
            var getWeak = function (it, create) {
                if (!has(it, META)) {
                    // can't set metadata to uncaught frozen object
                    if (!isExtensible(it)) return true;
                    // not necessary to add metadata
                    if (!create) return false;
                    // add missing metadata
                    setMeta(it);
                    // return hash weak collections IDs
                } return it[META].w;
            };
// add metadata on freeze-family methods calling
            var onFreeze = function (it) {
                if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
                return it;
            };
            var meta = module.exports = {
                KEY: META,
                NEED: false,
                fastKey: fastKey,
                getWeak: getWeak,
                onFreeze: onFreeze
            };


            /***/ }),
        /* 101 */
        /***/ (function(module, exports, __webpack_require__) {

// all enumerable object keys, includes symbols
            var getKeys = __webpack_require__(12);
            var gOPS = __webpack_require__(30);
            var pIE = __webpack_require__(20);
            module.exports = function (it) {
                var result = getKeys(it);
                var getSymbols = gOPS.f;
                if (getSymbols) {
                    var symbols = getSymbols(it);
                    var isEnum = pIE.f;
                    var i = 0;
                    var key;
                    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
                } return result;
            };


            /***/ }),
        /* 102 */
        /***/ (function(module, exports, __webpack_require__) {

// 7.2.2 IsArray(argument)
            var cof = __webpack_require__(13);
            module.exports = Array.isArray || function isArray(arg) {
                    return cof(arg) == 'Array';
                };


            /***/ }),
        /* 103 */
        /***/ (function(module, exports, __webpack_require__) {

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
            var toIObject = __webpack_require__(11);
            var gOPN = __webpack_require__(57).f;
            var toString = {}.toString;

            var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
                ? Object.getOwnPropertyNames(window) : [];

            var getWindowNames = function (it) {
                try {
                    return gOPN(it);
                } catch (e) {
                    return windowNames.slice();
                }
            };

            module.exports.f = function getOwnPropertyNames(it) {
                return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
            };


            /***/ }),
        /* 104 */
        /***/ (function(module, exports, __webpack_require__) {

            var pIE = __webpack_require__(20);
            var createDesc = __webpack_require__(18);
            var toIObject = __webpack_require__(11);
            var toPrimitive = __webpack_require__(24);
            var has = __webpack_require__(9);
            var IE8_DOM_DEFINE = __webpack_require__(38);
            var gOPD = Object.getOwnPropertyDescriptor;

            exports.f = __webpack_require__(8) ? gOPD : function getOwnPropertyDescriptor(O, P) {
                O = toIObject(O);
                P = toPrimitive(P, true);
                if (IE8_DOM_DEFINE) try {
                    return gOPD(O, P);
                } catch (e) { /* empty */ }
                if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
            };


            /***/ }),
        /* 105 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(35)('asyncIterator');


            /***/ }),
        /* 106 */
        /***/ (function(module, exports, __webpack_require__) {

            __webpack_require__(35)('observable');


            /***/ }),
        /* 107 */
        /***/ (function(module, exports, __webpack_require__) {

            "use strict";


            exports.__esModule = true;
            exports.StatisticsLogger = undefined;

            var _keys = __webpack_require__(55);

            var _keys2 = _interopRequireDefault(_keys);

            var _classCallCheck2 = __webpack_require__(33);

            var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

            var _utils = __webpack_require__(15);

            function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

            var StatisticsLogger = exports.StatisticsLogger = function () {
                function StatisticsLogger() {
                    (0, _classCallCheck3["default"])(this, StatisticsLogger);
                }

                StatisticsLogger.prototype.log = function log(info, token) {
                    var logString = "";
                    (0, _keys2["default"])(info).forEach(function (k) {
                        return logString += info[k] + ",";
                    });
                    this.send(logString, token);
                };

                StatisticsLogger.prototype.send = function send(logString, token) {
                    var xhr = (0, _utils.createXHR)();
                    var count = 0;
                    xhr.open('POST', "https://uplog.qbox.me/log/3");
                    xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
                    xhr.setRequestHeader('Authorization', 'UpToken ' + token);
                    xhr.onreadystatechange = function () {
                        if (xhr.readyState === 4) {
                            if (xhr.status !== 200) {
                                count++;
                                count <= 3 ? xhr.send(logString) : "";
                            }
                        }
                    };
                    xhr.send(logString);
                };

                return StatisticsLogger;
            }();

            /***/ })
        /******/ ]);
});